package com.xuan.bazi.core;

import com.xuan.bazi.core.constant.Constant;

import java.util.*;

/**
 * 八字集合
 *
 * @author kty
 */
public class BaZiMap {

    /**
     * 二十四小时对应十二地支
     */
    public static final Map<Integer, String> HOUR_ZHI = new HashMap<Integer, String>() {
        private static final long serialVersionUID = -1;

        {
            put(0, Constant.ZI_ZHI);    // 子
            put(1, Constant.CHOU_ZHI);  // 丑
            put(2, Constant.CHOU_ZHI);  // 丑
            put(3, Constant.YIN_ZHI);   // 寅
            put(4, Constant.YIN_ZHI);   // 寅
            put(5, Constant.MAO_ZHI);   // 卯
            put(6, Constant.MAO_ZHI);   // 卯
            put(7, Constant.CHEN_ZHI);  // 辰
            put(8, Constant.CHEN_ZHI);  // 辰
            put(9, Constant.SI_ZHI);    // 巳
            put(10, Constant.SI_ZHI);   // 巳
            put(11, Constant.WU_ZHI);   // 午
            put(12, Constant.WU_ZHI);   // 午
            put(13, Constant.WEI_ZHI);  // 未
            put(14, Constant.WEI_ZHI);  // 未
            put(15, Constant.SHEN_ZHI); // 申
            put(16, Constant.SHEN_ZHI); // 申
            put(17, Constant.YOU_ZHI);  // 酉
            put(18, Constant.YOU_ZHI);  // 酉
            put(19, Constant.XU_ZHI);   // 戌
            put(20, Constant.XU_ZHI);   // 戌
            put(21, Constant.HAI_ZHI);  // 亥
            put(22, Constant.HAI_ZHI);  // 亥
            put(23, Constant.ZI_ZHI);   // 子
        }

    };

    /**
     * 通过[天干]获取：天干五行
     * <hr>
     * <p>★例如</p>
     * <p>甲，五行属性为"木"</p>
     */
    public static final Map<String, String> GAN_WU_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put(Constant.JIA_GAN, Constant.MU);   // 甲：木
            put(Constant.YI_GAN, Constant.MU);    // 乙：木
            put(Constant.BING_GAN, Constant.HUO); // 丙：火
            put(Constant.DING_GAN, Constant.HUO); // 丁：火
            put(Constant.WU_GAN, Constant.TU);    // 戊：土
            put(Constant.JI_GAN, Constant.TU);    // 己：土
            put(Constant.GENG_GAN, Constant.JIN); // 庚：金
            put(Constant.XIN_GAN, Constant.JIN);  // 辛：金
            put(Constant.REN_GAN, Constant.SHUI); // 壬：水
            put(Constant.GUI_GAN, Constant.SHUI); // 癸：水
        }

    };

    /**
     * 通过[地支]获取：地支五行
     * <hr>
     * <p>★例如</p>
     * <p>子，五行属性为"水"</p>
     */
    public static final Map<String, String> ZHI_WU_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put(Constant.ZI_ZHI, Constant.SHUI);  // 子：水
            put(Constant.CHOU_ZHI, Constant.TU);  // 丑：土
            put(Constant.YIN_ZHI, Constant.MU);   // 寅：木
            put(Constant.MAO_ZHI, Constant.MU);   // 卯：木
            put(Constant.CHEN_ZHI, Constant.TU);  // 辰：土
            put(Constant.SI_ZHI, Constant.HUO);   // 巳：火
            put(Constant.WU_ZHI, Constant.HUO);   // 午：火
            put(Constant.WEI_ZHI, Constant.TU);   // 未：土
            put(Constant.SHEN_ZHI, Constant.JIN); // 申：金
            put(Constant.YOU_ZHI, Constant.JIN);  // 酉：金
            put(Constant.XU_ZHI, Constant.TU);    // 戌：土
            put(Constant.HAI_ZHI, Constant.SHUI); // 亥：水
        }

    };

    /**
     * 主星与副星
     */
    public static final Map<List<String>, String> ZHU_FU_XING = new HashMap<List<String>, String>() {
        private static final long serialVersionUID = -1;

        /*
            ★十神的生克关系：

                1、生我者为印缓（五行阴阳属性相同则为：偏印，五行阴阳属性不同则为：正印）
                2、我生者为子孙（五行阴阳属性相同则为：食神，五行阴阳属性不同则为：伤官）
                3、克我者为官鬼（五行阴阳属性相同则为：七杀，五行阴阳属性不同则为：正官）
                4、我克者为妻财（五行阴阳属性相同则为：偏财，五行阴阳属性不同则为：正财）
                5、同我者为兄弟（五行阴阳属性相同则为：比肩，五行阴阳属性不同则为：劫财）
         */

        {                                                                                // [我+者]
            put(Arrays.asList(Constant.JIA_GAN, Constant.JIA_GAN), Constant.BI_JIAN);     // 甲+甲（阳木+阳木）：比肩
            put(Arrays.asList(Constant.JIA_GAN, Constant.YI_GAN), Constant.JIE_CAI);      // 甲+乙（阳木+阴木）：劫财
            put(Arrays.asList(Constant.JIA_GAN, Constant.BING_GAN), Constant.SHI_SHEN);   // 甲+丙（阳木+阳火）：食神
            put(Arrays.asList(Constant.JIA_GAN, Constant.DING_GAN), Constant.SHANG_GUAN); // 甲+丁（阳木+阴火）：伤官
            put(Arrays.asList(Constant.JIA_GAN, Constant.WU_GAN), Constant.PIAN_CAI);     // 甲+戊（阳木+阳土）：偏财
            put(Arrays.asList(Constant.JIA_GAN, Constant.JI_GAN), Constant.ZHENG_CAI);    // 甲+己（阳木+阴土）：正财
            put(Arrays.asList(Constant.JIA_GAN, Constant.GENG_GAN), Constant.QI_SHA);     // 甲+庚（阳木+阳金）：七杀
            put(Arrays.asList(Constant.JIA_GAN, Constant.XIN_GAN), Constant.ZHENG_GUAN);  // 甲+辛（阳木+阴金）：正官
            put(Arrays.asList(Constant.JIA_GAN, Constant.REN_GAN), Constant.PIAN_YIN);    // 甲+壬（阳木+阳水）：偏印
            put(Arrays.asList(Constant.JIA_GAN, Constant.GUI_GAN), Constant.ZHENG_YIN);   // 甲+癸（阳木+阴水）：正印

            put(Arrays.asList(Constant.YI_GAN, Constant.JIA_GAN), Constant.JIE_CAI);     // 乙+甲（阴木+阳木）：劫财
            put(Arrays.asList(Constant.YI_GAN, Constant.YI_GAN), Constant.BI_JIAN);      // 乙+乙（阴木+阴木）：比肩
            put(Arrays.asList(Constant.YI_GAN, Constant.BING_GAN), Constant.SHANG_GUAN); // 乙+丙（阴木+阳火）：伤官
            put(Arrays.asList(Constant.YI_GAN, Constant.DING_GAN), Constant.SHI_SHEN);   // 乙+丁（阴木+阴火）：食神
            put(Arrays.asList(Constant.YI_GAN, Constant.WU_GAN), Constant.ZHENG_CAI);    // 乙+戊（阴木+阳土）：正财
            put(Arrays.asList(Constant.YI_GAN, Constant.JI_GAN), Constant.PIAN_CAI);     // 乙+己（阴木+阴土）：偏财
            put(Arrays.asList(Constant.YI_GAN, Constant.GENG_GAN), Constant.ZHENG_GUAN); // 乙+庚（阴木+阳金）：正官
            put(Arrays.asList(Constant.YI_GAN, Constant.XIN_GAN), Constant.QI_SHA);      // 乙+辛（阴木+阴金）：七杀
            put(Arrays.asList(Constant.YI_GAN, Constant.REN_GAN), Constant.ZHENG_YIN);   // 乙+壬（阴木+阳水）：正印
            put(Arrays.asList(Constant.YI_GAN, Constant.GUI_GAN), Constant.PIAN_YIN);    // 乙+癸（阴木+阴水）：偏印

            put(Arrays.asList(Constant.BING_GAN, Constant.JIA_GAN), Constant.PIAN_YIN);   // 丙+甲（阳火+阳木）：偏印
            put(Arrays.asList(Constant.BING_GAN, Constant.YI_GAN), Constant.ZHENG_YIN);   // 丙+乙（阳火+阴木）：正印
            put(Arrays.asList(Constant.BING_GAN, Constant.BING_GAN), Constant.BI_JIAN);   // 丙+丙（阳火+阳火）：比肩
            put(Arrays.asList(Constant.BING_GAN, Constant.DING_GAN), Constant.JIE_CAI);   // 丙+丁（阳火+阴火）：劫财
            put(Arrays.asList(Constant.BING_GAN, Constant.WU_GAN), Constant.SHI_SHEN);    // 丙+戊（阳火+阳土）：食神
            put(Arrays.asList(Constant.BING_GAN, Constant.JI_GAN), Constant.SHANG_GUAN);  // 丙+己（阳火+阴土）：伤官
            put(Arrays.asList(Constant.BING_GAN, Constant.GENG_GAN), Constant.PIAN_CAI);  // 丙+庚（阳火+阳金）：偏财
            put(Arrays.asList(Constant.BING_GAN, Constant.XIN_GAN), Constant.ZHENG_CAI);  // 丙+辛（阳火+阴金）：正财
            put(Arrays.asList(Constant.BING_GAN, Constant.REN_GAN), Constant.QI_SHA);     // 丙+壬（阳火+阳水）：七杀
            put(Arrays.asList(Constant.BING_GAN, Constant.GUI_GAN), Constant.ZHENG_GUAN); // 丙+癸（阳火+阴水）：正官

            put(Arrays.asList(Constant.DING_GAN, Constant.JIA_GAN), Constant.ZHENG_YIN);  // 丁+甲（阴火+阳木）：正印
            put(Arrays.asList(Constant.DING_GAN, Constant.YI_GAN), Constant.PIAN_YIN);    // 丁+乙（阴火+阴木）：偏印
            put(Arrays.asList(Constant.DING_GAN, Constant.BING_GAN), Constant.JIE_CAI);   // 丁+丙（阴火+阳火）：劫财
            put(Arrays.asList(Constant.DING_GAN, Constant.DING_GAN), Constant.BI_JIAN);   // 丁+丁（阴火+阴火）：比肩
            put(Arrays.asList(Constant.DING_GAN, Constant.WU_GAN), Constant.SHANG_GUAN);  // 丁+戊（阴火+阳土）：伤官
            put(Arrays.asList(Constant.DING_GAN, Constant.JI_GAN), Constant.SHI_SHEN);    // 丁+己（阴火+阴土）：食神
            put(Arrays.asList(Constant.DING_GAN, Constant.GENG_GAN), Constant.ZHENG_CAI); // 丁+庚（阴火+阳金）：正财
            put(Arrays.asList(Constant.DING_GAN, Constant.XIN_GAN), Constant.PIAN_CAI);   // 丁+辛（阴火+阴金）：偏财
            put(Arrays.asList(Constant.DING_GAN, Constant.REN_GAN), Constant.ZHENG_GUAN); // 丁+壬（阴火+阳水）：正官
            put(Arrays.asList(Constant.DING_GAN, Constant.GUI_GAN), Constant.QI_SHA);     // 丁+癸（阴火+阴水）：七杀

            put(Arrays.asList(Constant.WU_GAN, Constant.JIA_GAN), Constant.QI_SHA);     // 戊+甲（阳土+阳木）：七杀
            put(Arrays.asList(Constant.WU_GAN, Constant.YI_GAN), Constant.ZHENG_GUAN);  // 戊+乙（阳土+阴木）：正官
            put(Arrays.asList(Constant.WU_GAN, Constant.BING_GAN), Constant.PIAN_YIN);  // 戊+丙（阳土+阳火）：偏印
            put(Arrays.asList(Constant.WU_GAN, Constant.DING_GAN), Constant.ZHENG_YIN); // 戊+丁（阳土+阴火）：正印
            put(Arrays.asList(Constant.WU_GAN, Constant.WU_GAN), Constant.BI_JIAN);     // 戊+戊（阳土+阳土）：比肩
            put(Arrays.asList(Constant.WU_GAN, Constant.JI_GAN), Constant.JIE_CAI);     // 戊+己（阳土+阴土）：劫财
            put(Arrays.asList(Constant.WU_GAN, Constant.GENG_GAN), Constant.SHI_SHEN);  // 戊+庚（阳土+阳金）：食神
            put(Arrays.asList(Constant.WU_GAN, Constant.XIN_GAN), Constant.SHANG_GUAN); // 戊+辛（阳土+阴金）：伤官
            put(Arrays.asList(Constant.WU_GAN, Constant.REN_GAN), Constant.PIAN_CAI);   // 戊+壬（阳土+阳水）：偏财
            put(Arrays.asList(Constant.WU_GAN, Constant.GUI_GAN), Constant.ZHENG_CAI);  // 戊+癸（阳土+阴水）：正财

            put(Arrays.asList(Constant.JI_GAN, Constant.JIA_GAN), Constant.ZHENG_GUAN);  // 己+甲（阴土+阳木）：正官
            put(Arrays.asList(Constant.JI_GAN, Constant.YI_GAN), Constant.QI_SHA);       // 己+乙（阴土+阴木）：七杀
            put(Arrays.asList(Constant.JI_GAN, Constant.BING_GAN), Constant.ZHENG_YIN);  // 己+丙（阴土+阳火）：正印
            put(Arrays.asList(Constant.JI_GAN, Constant.DING_GAN), Constant.PIAN_YIN);   // 己+丁（阴土+阴火）：偏印
            put(Arrays.asList(Constant.JI_GAN, Constant.WU_GAN), Constant.JIE_CAI);      // 己+戊（阴土+阳土）：劫财
            put(Arrays.asList(Constant.JI_GAN, Constant.JI_GAN), Constant.BI_JIAN);      // 己+己（阴土+阴土）：比肩
            put(Arrays.asList(Constant.JI_GAN, Constant.GENG_GAN), Constant.SHANG_GUAN); // 己+庚（阴土+阳金）：伤官
            put(Arrays.asList(Constant.JI_GAN, Constant.XIN_GAN), Constant.SHI_SHEN);    // 己+辛（阴土+阴金）：食神
            put(Arrays.asList(Constant.JI_GAN, Constant.REN_GAN), Constant.ZHENG_CAI);   // 己+壬（阴土+阳水）：正财
            put(Arrays.asList(Constant.JI_GAN, Constant.GUI_GAN), Constant.PIAN_CAI);    // 己+癸（阴土+阴水）：偏财

            put(Arrays.asList(Constant.GENG_GAN, Constant.JIA_GAN), Constant.PIAN_CAI);    // 庚+甲（阳金+阳木）：偏财
            put(Arrays.asList(Constant.GENG_GAN, Constant.YI_GAN), Constant.ZHENG_CAI);    // 庚+乙（阳金+阴木）：正财
            put(Arrays.asList(Constant.GENG_GAN, Constant.BING_GAN), Constant.QI_SHA);     // 庚+丙（阳金+阳火）：七杀
            put(Arrays.asList(Constant.GENG_GAN, Constant.DING_GAN), Constant.ZHENG_GUAN); // 庚+丁（阳金+阴火）：正官
            put(Arrays.asList(Constant.GENG_GAN, Constant.WU_GAN), Constant.PIAN_YIN);     // 庚+戊（阳金+阳土）：偏印
            put(Arrays.asList(Constant.GENG_GAN, Constant.JI_GAN), Constant.ZHENG_YIN);    // 庚+己（阳金+阴土）：正印
            put(Arrays.asList(Constant.GENG_GAN, Constant.GENG_GAN), Constant.BI_JIAN);    // 庚+庚（阳金+阳金）：比肩
            put(Arrays.asList(Constant.GENG_GAN, Constant.XIN_GAN), Constant.JIE_CAI);     // 庚+辛（阳金+阴金）：劫财
            put(Arrays.asList(Constant.GENG_GAN, Constant.REN_GAN), Constant.SHI_SHEN);    // 庚+壬（阳金+阳水）：食神
            put(Arrays.asList(Constant.GENG_GAN, Constant.GUI_GAN), Constant.SHANG_GUAN);  // 庚+癸（阳金+阴水）：伤官

            put(Arrays.asList(Constant.XIN_GAN, Constant.JIA_GAN), Constant.ZHENG_CAI);   // 辛+甲（阴金+阳木）：正财
            put(Arrays.asList(Constant.XIN_GAN, Constant.YI_GAN), Constant.PIAN_CAI);     // 辛+乙（阴金+阴木）：偏财
            put(Arrays.asList(Constant.XIN_GAN, Constant.BING_GAN), Constant.ZHENG_GUAN); // 辛+丙（阴金+阳火）：正官
            put(Arrays.asList(Constant.XIN_GAN, Constant.DING_GAN), Constant.QI_SHA);     // 辛+丁（阴金+阴火）：七杀
            put(Arrays.asList(Constant.XIN_GAN, Constant.WU_GAN), Constant.ZHENG_YIN);    // 辛+戊（阴金+阳土）：正印
            put(Arrays.asList(Constant.XIN_GAN, Constant.JI_GAN), Constant.PIAN_YIN);     // 辛+己（阴金+阴土）：偏印
            put(Arrays.asList(Constant.XIN_GAN, Constant.GENG_GAN), Constant.JIE_CAI);    // 辛+庚（阴金+阳金）：劫财
            put(Arrays.asList(Constant.XIN_GAN, Constant.XIN_GAN), Constant.BI_JIAN);     // 辛+辛（阴金+阴金）：比肩
            put(Arrays.asList(Constant.XIN_GAN, Constant.REN_GAN), Constant.SHANG_GUAN);  // 辛+壬（阴金+阳水）：伤官
            put(Arrays.asList(Constant.XIN_GAN, Constant.GUI_GAN), Constant.SHI_SHEN);    // 辛+癸（阴金+阴水）：食神

            put(Arrays.asList(Constant.REN_GAN, Constant.JIA_GAN), Constant.SHI_SHEN);   // 壬+甲（阳水+阳木）：食神
            put(Arrays.asList(Constant.REN_GAN, Constant.YI_GAN), Constant.SHANG_GUAN);  // 壬+乙（阳水+阴木）：伤官
            put(Arrays.asList(Constant.REN_GAN, Constant.BING_GAN), Constant.PIAN_CAI);  // 壬+丙（阳水+阳火）：偏财
            put(Arrays.asList(Constant.REN_GAN, Constant.DING_GAN), Constant.ZHENG_CAI); // 壬+丁（阳水+阴火）：正财
            put(Arrays.asList(Constant.REN_GAN, Constant.WU_GAN), Constant.QI_SHA);      // 壬+戊（阳水+阳土）：七杀
            put(Arrays.asList(Constant.REN_GAN, Constant.JI_GAN), Constant.ZHENG_GUAN);  // 壬+己（阳水+阴土）：正官
            put(Arrays.asList(Constant.REN_GAN, Constant.GENG_GAN), Constant.PIAN_YIN);  // 壬+庚（阳水+阳金）：偏印
            put(Arrays.asList(Constant.REN_GAN, Constant.XIN_GAN), Constant.ZHENG_YIN);  // 壬+辛（阳水+阴金）：正印
            put(Arrays.asList(Constant.REN_GAN, Constant.REN_GAN), Constant.BI_JIAN);    // 壬+壬（阳水+阳水）：比肩
            put(Arrays.asList(Constant.REN_GAN, Constant.GUI_GAN), Constant.JIE_CAI);    // 壬+癸（阳水+阴水）：劫财

            put(Arrays.asList(Constant.GUI_GAN, Constant.JIA_GAN), Constant.SHANG_GUAN); // 癸+甲（阴水+阳木）：伤官
            put(Arrays.asList(Constant.GUI_GAN, Constant.YI_GAN), Constant.SHI_SHEN);    // 癸+乙（阴水+阴木）：食神
            put(Arrays.asList(Constant.GUI_GAN, Constant.BING_GAN), Constant.ZHENG_CAI); // 癸+丙（阴水+阳火）：正财
            put(Arrays.asList(Constant.GUI_GAN, Constant.DING_GAN), Constant.PIAN_CAI);  // 癸+丁（阴水+阴火）：偏财
            put(Arrays.asList(Constant.GUI_GAN, Constant.WU_GAN), Constant.ZHENG_GUAN);  // 癸+戊（阴水+阳土）：正官
            put(Arrays.asList(Constant.GUI_GAN, Constant.JI_GAN), Constant.QI_SHA);      // 癸+己（阴水+阴土）：七杀
            put(Arrays.asList(Constant.GUI_GAN, Constant.GENG_GAN), Constant.ZHENG_YIN); // 癸+庚（阴水+阳金）：正印
            put(Arrays.asList(Constant.GUI_GAN, Constant.XIN_GAN), Constant.PIAN_YIN);   // 癸+辛（阴水+阴金）：偏印
            put(Arrays.asList(Constant.GUI_GAN, Constant.REN_GAN), Constant.JIE_CAI);    // 癸+壬（阴水+阳水）：劫财
            put(Arrays.asList(Constant.GUI_GAN, Constant.GUI_GAN), Constant.BI_JIAN);    // 癸+癸（阴水+阴水）：比肩
        }

    };

    /**
     * 地支藏干
     */
    public static final Map<String, List<String>> DI_ZHI_CANG_GAN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
                《十二地支藏干口诀》

            子宫壬癸在其中，丑癸辛金己土同；
            寅宫甲木兼丙戊，卯宫甲乙木相逢，
            辰藏乙戊三分癸，已中庚金丙戊丛；
            午宫丙丁火己土，未宫乙己丁共宗；
            申位庚金壬水戊，酉宫庚辛金丰隆；
            戌宫辛金及丁戊，亥藏壬甲戊真踪。

            ==================================================================

            ★解释：
                1、 子：藏干为癸水。
                2、 丑：藏干为已土、癸水、辛金。（已土为本气，癸水为中气，辛金为余气）
                3、 寅：藏干为甲木、丙火、戊土。（甲木为本气，丙火为中气，戊土为余气）
                4、 卯：藏干为乙木。
                5、 辰：藏干为戊土、乙木、癸水。（戊土为本气，乙木为中气，癸水为余气）
                6、 已：藏干为丙火、庚金、戊土。（丙火为本气，庚金为中气，戊土为余气）
                7、 午：藏干为丁火、已土。（丁火为本气，已土为中气）
                8、 未：藏干为已土、丁火、乙木。（已土为本气，丁火为中气，乙木为余气）
                9、 申：藏干为庚金、壬水、戊土。（庚金为本气，壬水为中气，戊土为余气）
                10、酉：藏干为辛金。
                11、戌：藏干为戊土、辛金、丁火。（戊土为本气，辛金为中气，丁火为余气）
                12、亥：藏干为壬水、甲木。（壬水为本气，甲木为中气）
        */

        {
            put(Constant.ZI_ZHI, Collections.singletonList(Constant.GUI_GAN + Constant.SHUI));                                                        // 子：癸水
            put(Constant.CHOU_ZHI, Arrays.asList(Constant.JI_GAN + Constant.TU, Constant.GUI_GAN + Constant.SHUI, Constant.XIN_GAN + Constant.JIN));  // 丑：已土、癸水、辛金
            put(Constant.YIN_ZHI, Arrays.asList(Constant.JIA_GAN + Constant.MU, Constant.BING_GAN + Constant.HUO, Constant.WU_GAN + Constant.TU));    // 寅：甲木、丙火、戊土
            put(Constant.MAO_ZHI, Collections.singletonList(Constant.YI_GAN + Constant.MU));                                                          // 卯：乙木
            put(Constant.CHEN_ZHI, Arrays.asList(Constant.WU_GAN + Constant.TU, Constant.YI_GAN + Constant.MU, Constant.GUI_GAN + Constant.SHUI));    // 辰：戊土、乙木、癸水
            put(Constant.SI_ZHI, Arrays.asList(Constant.BING_GAN + Constant.HUO, Constant.GENG_GAN + Constant.JIN, Constant.WU_GAN + Constant.TU));   // 巳：丙火、庚金、戊土
            put(Constant.WU_ZHI, Arrays.asList(Constant.DING_GAN + Constant.HUO, Constant.JI_GAN + Constant.TU));                                     // 午：丁火、已土
            put(Constant.WEI_ZHI, Arrays.asList(Constant.JI_GAN + Constant.TU, Constant.DING_GAN + Constant.HUO, Constant.YI_GAN + Constant.MU));     // 未：已土、丁火、乙木
            put(Constant.SHEN_ZHI, Arrays.asList(Constant.GENG_GAN + Constant.JIN, Constant.REN_GAN + Constant.SHUI, Constant.WU_GAN + Constant.TU)); // 申：庚金、壬水、戊土
            put(Constant.YOU_ZHI, Collections.singletonList(Constant.XIN_GAN + Constant.JIN));                                                        // 酉：辛金
            put(Constant.XU_ZHI, Arrays.asList(Constant.WU_GAN + Constant.TU, Constant.XIN_GAN + Constant.JIN, Constant.DING_GAN + Constant.HUO));    // 戌：戊土、辛金、丁火
            put(Constant.HAI_ZHI, Arrays.asList(Constant.REN_GAN + Constant.SHUI, Constant.JIA_GAN + Constant.MU));                                   // 亥：壬水、甲木
        }

    };

    /**
     * 天干和天干的[五行生克]
     */
    public static final Map<List<String>, List<String>> GAN_GAN_WU_XING_SHENG_KE = new HashMap<List<String>, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            1、同我、生我为：强。

            2、克我、我生、我克为：弱。
               ①克我为：克
               ②我生为：泄
               ③我克为：耗
         */

        {
            put(Arrays.asList(Constant.JIA_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.QIANG)); // 甲+甲：身强（同我。甲同甲→木同木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.YI_GAN), Collections.singletonList(Constant.QIANG));  // 甲+乙：身强（同我。甲同乙→木同木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.BING_GAN), Collections.singletonList(Constant.RUO));  // 甲+丙：身弱（我生。甲生丙→木生火）
            put(Arrays.asList(Constant.JIA_GAN, Constant.DING_GAN), Collections.singletonList(Constant.RUO));  // 甲+丁：身弱（我生。甲生丁→木生火）
            put(Arrays.asList(Constant.JIA_GAN, Constant.WU_GAN), Collections.singletonList(Constant.RUO));    // 甲+戊：身弱（我克。甲克戌→木克土）
            put(Arrays.asList(Constant.JIA_GAN, Constant.JI_GAN), Collections.singletonList(Constant.RUO));    // 甲+己：身弱（我克。甲克己→木克土）
            put(Arrays.asList(Constant.JIA_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.RUO));  // 甲+庚：身弱（克我。庚克甲→金克木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.RUO));   // 甲+辛：身弱（克我。辛克甲→金克木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.REN_GAN), Collections.singletonList(Constant.QIANG)); // 甲+壬：身强（生我。壬生甲→水生木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.QIANG)); // 甲+癸：身强（生我。癸生甲→水生木）

            put(Arrays.asList(Constant.YI_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.QIANG)); // 乙+甲：身强（同我。乙同甲→木同木）
            put(Arrays.asList(Constant.YI_GAN, Constant.YI_GAN), Collections.singletonList(Constant.QIANG));  // 乙+乙：身强（同我。乙同乙→木同木）
            put(Arrays.asList(Constant.YI_GAN, Constant.BING_GAN), Collections.singletonList(Constant.RUO));  // 乙+丙：身弱（我生。乙生丙→木生火）
            put(Arrays.asList(Constant.YI_GAN, Constant.DING_GAN), Collections.singletonList(Constant.RUO));  // 乙+丁：身弱（我生。乙生丁→木生火）
            put(Arrays.asList(Constant.YI_GAN, Constant.WU_GAN), Collections.singletonList(Constant.RUO));    // 乙+戊：身弱（我克。乙克戌→木克土）
            put(Arrays.asList(Constant.YI_GAN, Constant.JI_GAN), Collections.singletonList(Constant.RUO));    // 乙+己：身弱（我克。乙克己→木克土）
            put(Arrays.asList(Constant.YI_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.RUO));  // 乙+庚：身弱（克我。庚克乙→金克木）
            put(Arrays.asList(Constant.YI_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.RUO));   // 乙+辛：身弱（克我。辛克乙→金克木）
            put(Arrays.asList(Constant.YI_GAN, Constant.REN_GAN), Collections.singletonList(Constant.QIANG)); // 乙+壬：身强（生我。壬生乙→水生木）
            put(Arrays.asList(Constant.YI_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.QIANG)); // 乙+癸：身强（生我。癸生乙→水生木）

            put(Arrays.asList(Constant.BING_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.QIANG));  // 丙+甲：身强（生我。甲生丙→木生火）
            put(Arrays.asList(Constant.BING_GAN, Constant.YI_GAN), Collections.singletonList(Constant.QIANG));   // 丙+乙：身强（生我。乙生丙→木生火）
            put(Arrays.asList(Constant.BING_GAN, Constant.BING_GAN), Collections.singletonList(Constant.QIANG)); // 丙+丙：身强（同我。丙同丙→火同火）
            put(Arrays.asList(Constant.BING_GAN, Constant.DING_GAN), Collections.singletonList(Constant.QIANG)); // 丙+丁：身强（同我。丙同丁→火同火）
            put(Arrays.asList(Constant.BING_GAN, Constant.WU_GAN), Collections.singletonList(Constant.RUO));     // 丙+戊：身弱（我生。丙生戊→火生土）
            put(Arrays.asList(Constant.BING_GAN, Constant.JI_GAN), Collections.singletonList(Constant.RUO));     // 丙+己：身弱（我生。丙生己→火生土）
            put(Arrays.asList(Constant.BING_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.RUO));   // 丙+庚：身弱（我克。丙克庚→火克金）
            put(Arrays.asList(Constant.BING_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.RUO));    // 丙+辛：身弱（我克。丙克辛→火克金）
            put(Arrays.asList(Constant.BING_GAN, Constant.REN_GAN), Collections.singletonList(Constant.RUO));    // 丙+壬：身弱（克我。壬克丙→水克火）
            put(Arrays.asList(Constant.BING_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.RUO));    // 丙+癸：身弱（克我。癸克丙→水克火）

            put(Arrays.asList(Constant.DING_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.QIANG));  // 丁+甲：身强（生我。甲生丁→木生火）
            put(Arrays.asList(Constant.DING_GAN, Constant.YI_GAN), Collections.singletonList(Constant.QIANG));   // 丁+乙：身强（生我。乙生丁→木生火）
            put(Arrays.asList(Constant.DING_GAN, Constant.BING_GAN), Collections.singletonList(Constant.QIANG)); // 丁+丙：身强（同我。丁同丙→火同火）
            put(Arrays.asList(Constant.DING_GAN, Constant.DING_GAN), Collections.singletonList(Constant.QIANG)); // 丁+丁：身强（同我。丁同丁→火同火）
            put(Arrays.asList(Constant.DING_GAN, Constant.WU_GAN), Collections.singletonList(Constant.RUO));     // 丁+戊：身弱（我生。丁生戊→火生土）
            put(Arrays.asList(Constant.DING_GAN, Constant.JI_GAN), Collections.singletonList(Constant.RUO));     // 丁+己：身弱（我生。丁生己→火生土）
            put(Arrays.asList(Constant.DING_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.RUO));   // 丁+庚：身弱（我克。丁克庚→火克金）
            put(Arrays.asList(Constant.DING_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.RUO));    // 丁+辛：身弱（我克。丁克辛→火克金）
            put(Arrays.asList(Constant.DING_GAN, Constant.REN_GAN), Collections.singletonList(Constant.RUO));    // 丁+壬：身弱（克我。壬克丁→水克火）
            put(Arrays.asList(Constant.DING_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.RUO));    // 丁+癸：身弱（克我。癸克丁→水克火）

            put(Arrays.asList(Constant.WU_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.RUO));    // 戊+甲：身弱（克我。甲克戊→木克土）
            put(Arrays.asList(Constant.WU_GAN, Constant.YI_GAN), Collections.singletonList(Constant.RUO));     // 戊+乙：身弱（克我。乙克戊→木克土）
            put(Arrays.asList(Constant.WU_GAN, Constant.BING_GAN), Collections.singletonList(Constant.QIANG)); // 戊+丙：身强（生我。丙生戊→火生土）
            put(Arrays.asList(Constant.WU_GAN, Constant.DING_GAN), Collections.singletonList(Constant.QIANG)); // 戊+丁：身强（生我。丁生戊→火生土）
            put(Arrays.asList(Constant.WU_GAN, Constant.WU_GAN), Collections.singletonList(Constant.QIANG));   // 戊+戊：身强（同我。戊同戊→土同土）
            put(Arrays.asList(Constant.WU_GAN, Constant.JI_GAN), Collections.singletonList(Constant.QIANG));   // 戊+己：身强（同我。戊同己→土同土）
            put(Arrays.asList(Constant.WU_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.RUO));   // 戊+庚：身弱（我生。戊生庚→土生金）
            put(Arrays.asList(Constant.WU_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.RUO));    // 戊+辛：身弱（我生。戊生辛→土生金）
            put(Arrays.asList(Constant.WU_GAN, Constant.REN_GAN), Collections.singletonList(Constant.RUO));    // 戊+壬：身弱（我克。戊克壬→土克水）
            put(Arrays.asList(Constant.WU_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.RUO));    // 戊+癸：身弱（我克。戊克癸→土克水）

            put(Arrays.asList(Constant.JI_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.RUO));    // 己+甲：身弱（克我。甲克己→木克土）
            put(Arrays.asList(Constant.JI_GAN, Constant.YI_GAN), Collections.singletonList(Constant.RUO));     // 己+乙：身弱（克我。乙克己→木克土）
            put(Arrays.asList(Constant.JI_GAN, Constant.BING_GAN), Collections.singletonList(Constant.QIANG)); // 己+丙：身强（生我。丙生己→火生土）
            put(Arrays.asList(Constant.JI_GAN, Constant.DING_GAN), Collections.singletonList(Constant.QIANG)); // 己+丁：身强（生我。丁生己→火生土）
            put(Arrays.asList(Constant.JI_GAN, Constant.WU_GAN), Collections.singletonList(Constant.QIANG));   // 己+戊：身强（同我。己同戊→土同土）
            put(Arrays.asList(Constant.JI_GAN, Constant.JI_GAN), Collections.singletonList(Constant.QIANG));   // 己+己：身强（同我。己同己→土同土）
            put(Arrays.asList(Constant.JI_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.RUO));   // 己+庚：身弱（我生。己生庚→土生金）
            put(Arrays.asList(Constant.JI_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.RUO));    // 己+辛：身弱（我生。己生辛→土生金）
            put(Arrays.asList(Constant.JI_GAN, Constant.REN_GAN), Collections.singletonList(Constant.RUO));    // 己+壬：身弱（我克。己克壬→土克水）
            put(Arrays.asList(Constant.JI_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.RUO));    // 己+癸：身弱（我克。己克癸→土克水）

            put(Arrays.asList(Constant.GENG_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.RUO));    // 庚+甲：身弱（我克。庚克甲→金克木）
            put(Arrays.asList(Constant.GENG_GAN, Constant.YI_GAN), Collections.singletonList(Constant.RUO));     // 庚+乙：身弱（我克。庚克乙→金克木）
            put(Arrays.asList(Constant.GENG_GAN, Constant.BING_GAN), Collections.singletonList(Constant.RUO));   // 庚+丙：身弱（克我。丙克庚→火克金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.DING_GAN), Collections.singletonList(Constant.RUO));   // 庚+丁：身弱（克我。丁克庚→火克金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.WU_GAN), Collections.singletonList(Constant.QIANG));   // 庚+戊：身强（生我。戊生庚→土生金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.JI_GAN), Collections.singletonList(Constant.QIANG));   // 庚+己：身强（生我。己生庚→土生金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.QIANG)); // 庚+庚：身强（同我。庚同庚→金同金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.QIANG));  // 庚+辛：身强（同我。庚同辛→金同金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.REN_GAN), Collections.singletonList(Constant.RUO));    // 庚+壬：身弱（我生。庚生壬→金生水）
            put(Arrays.asList(Constant.GENG_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.RUO));    // 庚+癸：身弱（我生。庚生癸→金生水）

            put(Arrays.asList(Constant.XIN_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.RUO));    // 辛+甲：身弱（我克。辛克甲→金克木）
            put(Arrays.asList(Constant.XIN_GAN, Constant.YI_GAN), Collections.singletonList(Constant.RUO));     // 辛+乙：身弱（我克。辛克乙→金克木）
            put(Arrays.asList(Constant.XIN_GAN, Constant.BING_GAN), Collections.singletonList(Constant.RUO));   // 辛+丙：身弱（克我。丙克辛→火克金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.DING_GAN), Collections.singletonList(Constant.RUO));   // 辛+丁：身弱（克我。丁克辛→火克金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.WU_GAN), Collections.singletonList(Constant.QIANG));   // 辛+戊：身强（生我。戊生辛→土生金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.JI_GAN), Collections.singletonList(Constant.QIANG));   // 辛+己：身强（生我。己生辛→土生金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.QIANG)); // 辛+庚：身强（同我。辛同庚→金同金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.QIANG));  // 辛+辛：身强（同我。辛同辛→金同金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.REN_GAN), Collections.singletonList(Constant.RUO));    // 辛+壬：身弱（我生。辛生壬→金生水）
            put(Arrays.asList(Constant.XIN_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.RUO));    // 辛+癸：身弱（我生。辛生癸→金生水）

            put(Arrays.asList(Constant.REN_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.RUO));    // 壬+甲：身弱（我生。壬生甲→水生木）
            put(Arrays.asList(Constant.REN_GAN, Constant.YI_GAN), Collections.singletonList(Constant.RUO));     // 壬+乙：身弱（我生。壬生乙→水生木）
            put(Arrays.asList(Constant.REN_GAN, Constant.BING_GAN), Collections.singletonList(Constant.RUO));   // 壬+丙：身弱（我克。壬克丙→水克火）
            put(Arrays.asList(Constant.REN_GAN, Constant.DING_GAN), Collections.singletonList(Constant.RUO));   // 壬+丁：身弱（我克。壬克丁→水克火）
            put(Arrays.asList(Constant.REN_GAN, Constant.WU_GAN), Collections.singletonList(Constant.RUO));     // 壬+戊：身弱（克我。戊克壬→土克水）
            put(Arrays.asList(Constant.REN_GAN, Constant.JI_GAN), Collections.singletonList(Constant.RUO));     // 壬+己：身弱（克我。己克壬→土克水）
            put(Arrays.asList(Constant.REN_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.QIANG)); // 壬+庚：身强（生我。庚生壬→金生水）
            put(Arrays.asList(Constant.REN_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.QIANG));  // 壬+辛：身强（生我。辛生壬→金生水）
            put(Arrays.asList(Constant.REN_GAN, Constant.REN_GAN), Collections.singletonList(Constant.QIANG));  // 壬+壬：身强（同我。壬同壬→水同水）
            put(Arrays.asList(Constant.REN_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.QIANG));  // 壬+癸：身强（同我。壬同癸→水同水）

            put(Arrays.asList(Constant.GUI_GAN, Constant.JIA_GAN), Collections.singletonList(Constant.RUO));    // 癸+甲：身弱（我生。癸生甲→水生木）
            put(Arrays.asList(Constant.GUI_GAN, Constant.YI_GAN), Collections.singletonList(Constant.RUO));     // 癸+乙：身弱（我生。癸生乙→水生木）
            put(Arrays.asList(Constant.GUI_GAN, Constant.BING_GAN), Collections.singletonList(Constant.RUO));   // 癸+丙：身弱（我克。癸克丙→水克火）
            put(Arrays.asList(Constant.GUI_GAN, Constant.DING_GAN), Collections.singletonList(Constant.RUO));   // 癸+丁：身弱（我克。癸克丁→水克火）
            put(Arrays.asList(Constant.GUI_GAN, Constant.WU_GAN), Collections.singletonList(Constant.RUO));     // 癸+戊：身弱（克我。戊克癸→土克水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.JI_GAN), Collections.singletonList(Constant.RUO));     // 癸+己：身弱（克我。己克癸→土克水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.GENG_GAN), Collections.singletonList(Constant.QIANG)); // 癸+庚：身强（生我。庚生癸→金生水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.XIN_GAN), Collections.singletonList(Constant.QIANG));  // 癸+辛：身强（生我。辛生癸→金生水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.REN_GAN), Collections.singletonList(Constant.QIANG));  // 癸+壬：身强（同我。癸同壬→水同水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.GUI_GAN), Collections.singletonList(Constant.QIANG));  // 癸+癸：身强（同我。癸同癸→水同水）

        }

    };

    /**
     * 天干和地支的[五行生克]
     */
    public static final Map<List<String>, List<String>> GAN_ZHI_WU_XING_SHENG_KE = new HashMap<List<String>, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            1、同我、生我为：强。

            2、克我、我生、我克为：弱。
               ①克我为：克
               ②我生为：泄
               ③我克为：耗
         */

        {
            put(Arrays.asList(Constant.JIA_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.QIANG));  // 甲+子：身强（生我。子生甲→水生木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.RUO));  // 甲+丑：身弱（我克。甲克丑→木克土）
            put(Arrays.asList(Constant.JIA_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.QIANG)); // 甲+寅：身强（同我。甲同寅→木同木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.QIANG)); // 甲+卯：身强（同我。甲同卯→木同木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.RUO));  // 甲+辰：身弱（我克。甲克辰→木克土）
            put(Arrays.asList(Constant.JIA_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.RUO));    // 甲+巳：身弱（我生。甲生巳→木生火）
            put(Arrays.asList(Constant.JIA_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.RUO));    // 甲+午：身弱（我生。甲生午→木生火）
            put(Arrays.asList(Constant.JIA_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.RUO));   // 甲+未：身弱（我克。甲克未→木克土）
            put(Arrays.asList(Constant.JIA_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.RUO));  // 甲+申：身弱（克我。申克甲→金克木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.RUO));   // 甲+酉：身弱（克我。酉克甲→金克木）
            put(Arrays.asList(Constant.JIA_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.RUO));    // 甲+戌：身弱（我克。甲克戌→木克土）
            put(Arrays.asList(Constant.JIA_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.QIANG)); // 甲+亥：身强（生我。亥生甲→水生木）

            put(Arrays.asList(Constant.YI_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.QIANG));   // 乙+子：身强（生我。子生乙→水生木）
            put(Arrays.asList(Constant.YI_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.RUO));   // 乙+丑：身弱（我克。乙克丑→木克土）
            put(Arrays.asList(Constant.YI_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.QIANG));  // 乙+寅：身强（同我。乙同寅→木同木）
            put(Arrays.asList(Constant.YI_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.QIANG));  // 乙+卯：身强（同我。乙同卯→木同木）
            put(Arrays.asList(Constant.YI_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.RUO));   // 乙+辰：身弱（我克。乙克辰→木克土）
            put(Arrays.asList(Constant.YI_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.RUO));     // 乙+巳：身弱（我生。乙生巳→木生火）
            put(Arrays.asList(Constant.YI_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.RUO));     // 乙+午：身弱（我生。乙生午→木生火）
            put(Arrays.asList(Constant.YI_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.RUO));    // 乙+未：身弱（我克。乙克未→木克土）
            put(Arrays.asList(Constant.YI_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.RUO));   // 乙+申：身弱（克我。申克乙→金克木）
            put(Arrays.asList(Constant.YI_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.RUO));    // 乙+酉：身弱（克我。酉克乙→金克木）
            put(Arrays.asList(Constant.YI_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.RUO));     // 乙+戌：身弱（我克。乙克戌→木克土）
            put(Arrays.asList(Constant.YI_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.QIANG));  // 乙+亥：身强（生我。亥生乙→水生木）

            put(Arrays.asList(Constant.BING_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.RUO));    // 丙+子：身弱（克我。子克丙→水克火）
            put(Arrays.asList(Constant.BING_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.RUO));  // 丙+丑：身弱（我生。丙生丑→火生土）
            put(Arrays.asList(Constant.BING_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.QIANG)); // 丙+寅：身强（生我。丙生寅→木生火）
            put(Arrays.asList(Constant.BING_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.QIANG)); // 丙+卯：身强（生我。丙生卯→木生火）
            put(Arrays.asList(Constant.BING_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.RUO));  // 丙+辰：身弱（我生。丙生辰→火生土）
            put(Arrays.asList(Constant.BING_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.QIANG));  // 丙+巳：身强（同我。丙同巳→火同火）
            put(Arrays.asList(Constant.BING_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.QIANG));  // 丙+午：身强（同我。丙同午→火同火）
            put(Arrays.asList(Constant.BING_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.RUO));   // 丙+未：身弱（我生。丙生未→火生土）
            put(Arrays.asList(Constant.BING_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.RUO));  // 丙+申：身弱（我克。丙克申→火克金）
            put(Arrays.asList(Constant.BING_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.RUO));   // 丙+酉：身弱（我克。丙克酉→火克金）
            put(Arrays.asList(Constant.BING_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.RUO));    // 丙+戌：身弱（我生。丙生戌→火生土）
            put(Arrays.asList(Constant.BING_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.RUO));   // 丙+亥：身弱（克我。亥克丙→水克火）

            put(Arrays.asList(Constant.DING_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.RUO));    // 丁+子：身弱（克我。子克丁→水克火）
            put(Arrays.asList(Constant.DING_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.RUO));  // 丁+丑：身弱（我生。丁生丑→火生土）
            put(Arrays.asList(Constant.DING_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.QIANG)); // 丁+寅：身强（生我。丁生寅→木生火）
            put(Arrays.asList(Constant.DING_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.QIANG)); // 丁+卯：身强（生我。丁生卯→木生火）
            put(Arrays.asList(Constant.DING_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.RUO));  // 丁+辰：身弱（我生。丁生辰→火生土）
            put(Arrays.asList(Constant.DING_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.QIANG));  // 丁+巳：身强（同我。丁同巳→火同火）
            put(Arrays.asList(Constant.DING_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.QIANG));  // 丁+午：身强（同我。丁同午→火同火）
            put(Arrays.asList(Constant.DING_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.RUO));   // 丁+未：身弱（我生。丁生未→火生土）
            put(Arrays.asList(Constant.DING_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.RUO));  // 丁+申：身弱（我克。丁克申→火克金）
            put(Arrays.asList(Constant.DING_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.RUO));   // 丁+酉：身弱（我克。丁克酉→火克金）
            put(Arrays.asList(Constant.DING_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.RUO));    // 丁+戌：身弱（我生。丁生戌→火生土）
            put(Arrays.asList(Constant.DING_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.RUO));   // 丁+亥：身弱（克我。亥克丁→水克火）

            put(Arrays.asList(Constant.WU_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.RUO));     // 戊+子：身弱（我克。戊克子→土克水）
            put(Arrays.asList(Constant.WU_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.QIANG)); // 戊+丑：身强（同我。戊同丑→土同土）
            put(Arrays.asList(Constant.WU_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.RUO));    // 戊+寅：身弱（克我。寅克戊→木克土）
            put(Arrays.asList(Constant.WU_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.RUO));    // 戊+卯：身弱（克我。卯克戊→木克土）
            put(Arrays.asList(Constant.WU_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 戊+辰：身强（同我。戊同辰→土同土）
            put(Arrays.asList(Constant.WU_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.QIANG));   // 戊+巳：身强（生我。巳生戊→火生土）
            put(Arrays.asList(Constant.WU_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.QIANG));   // 戊+午：身强（生我。午生戊→火生土）
            put(Arrays.asList(Constant.WU_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.QIANG));  // 戊+未：身强（同我。戊同未→土同土）
            put(Arrays.asList(Constant.WU_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.RUO));   // 戊+申：身弱（我生。戊生申→土生金）
            put(Arrays.asList(Constant.WU_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.RUO));    // 戊+酉：身弱（我生。戊生酉→土生金）
            put(Arrays.asList(Constant.WU_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.QIANG));   // 戊+戌：身强（同我。戊同戌→土同土）
            put(Arrays.asList(Constant.WU_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.RUO));    // 戊+亥：身弱（我克。戊克亥→土克水）

            put(Arrays.asList(Constant.JI_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.RUO));     // 己+子：身弱（我克。己克子→土克水）
            put(Arrays.asList(Constant.JI_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.QIANG)); // 己+丑：身强（同我。己同丑→土同土）
            put(Arrays.asList(Constant.JI_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.RUO));    // 己+寅：身弱（克我。寅克己→木克土）
            put(Arrays.asList(Constant.JI_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.RUO));    // 己+卯：身弱（克我。卯克己→木克土）
            put(Arrays.asList(Constant.JI_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 己+辰：身强（同我。己同辰→土同土）
            put(Arrays.asList(Constant.JI_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.QIANG));   // 己+巳：身强（生我。巳生己→火生土）
            put(Arrays.asList(Constant.JI_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.QIANG));   // 己+午：身强（生我。午生己→火生土）
            put(Arrays.asList(Constant.JI_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.QIANG));  // 己+未：身强（同我。己同未→土同土）
            put(Arrays.asList(Constant.JI_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.RUO));   // 己+申：身弱（我生。己生申→土生金）
            put(Arrays.asList(Constant.JI_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.RUO));    // 己+酉：身弱（我生。己生酉→土生金）
            put(Arrays.asList(Constant.JI_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.QIANG));   // 己+戌：身强（同我。己同戌→土同土）
            put(Arrays.asList(Constant.JI_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.RUO));    // 己+亥：身弱（我克。己克亥→土克水）

            put(Arrays.asList(Constant.GENG_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.RUO));     // 庚+子：身弱（我生。庚生子→金生水）
            put(Arrays.asList(Constant.GENG_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.QIANG)); // 庚+丑：身强（生我。丑生庚→土生金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.RUO));    // 庚+寅：身弱（我克。庚克寅→金克木）
            put(Arrays.asList(Constant.GENG_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.RUO));    // 庚+卯：身弱（我克。庚克卯→金克木）
            put(Arrays.asList(Constant.GENG_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 庚+辰：身强（生我。辰生庚→土生金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.RUO));     // 庚+巳：身弱（克我。巳克庚→火克金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.RUO));     // 庚+午：身弱（克我。午克庚→火克金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.QIANG));  // 庚+未：身强（生我。未生庚→土生金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 庚+申：身强（同我。庚同申→金同金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.QIANG));  // 庚+酉：身强（同我。庚同酉→金同金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.QIANG));   // 庚+戌：身强（生我。戌生庚→土生金）
            put(Arrays.asList(Constant.GENG_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.RUO));    // 庚+亥：身弱（我生。庚生亥→金生水）

            put(Arrays.asList(Constant.XIN_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.RUO));     // 辛+子：身弱（我生。辛生子→金生水）
            put(Arrays.asList(Constant.XIN_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.QIANG)); // 辛+丑：身强（生我。丑生辛→土生金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.RUO));    // 辛+寅：身弱（我克。辛克寅→金克木）
            put(Arrays.asList(Constant.XIN_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.RUO));    // 辛+卯：身弱（我克。辛克卯→金克木）
            put(Arrays.asList(Constant.XIN_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 辛+辰：身强（生我。辰生辛→土生金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.RUO));     // 辛+巳：身弱（克我。巳克辛→火克金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.RUO));     // 辛+午：身弱（克我。午克辛→火克金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.QIANG));  // 辛+未：身强（生我。未生辛→土生金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 辛+申：身强（同我。辛同申→金同金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.QIANG));  // 辛+酉：身强（同我。辛同酉→金同金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.QIANG));   // 辛+戌：身强（生我。戌生辛→土生金）
            put(Arrays.asList(Constant.XIN_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.RUO));    // 辛+亥：身弱（我生。辛生亥→金生水）

            put(Arrays.asList(Constant.REN_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.QIANG));   // 壬+子：身强（同我。壬同子→水同水）
            put(Arrays.asList(Constant.REN_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.RUO));   // 壬+丑：身弱（克我。丑克壬→土克水）
            put(Arrays.asList(Constant.REN_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.RUO));    // 壬+寅：身弱（我生。寅生壬→水生木）
            put(Arrays.asList(Constant.REN_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.RUO));    // 壬+卯：身弱（我生。卯生壬→水生木）
            put(Arrays.asList(Constant.REN_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.RUO));   // 壬+辰：身弱（克我。辰克壬→土克水）
            put(Arrays.asList(Constant.REN_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.RUO));     // 壬+巳：身弱（我克。壬克巳→水克火）
            put(Arrays.asList(Constant.REN_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.RUO));     // 壬+午：身弱（我克。壬克午→水克火）
            put(Arrays.asList(Constant.REN_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.RUO));    // 壬+未：身弱（克我。未克壬→土克水）
            put(Arrays.asList(Constant.REN_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 壬+申：身强（生我。申生壬→金生水）
            put(Arrays.asList(Constant.REN_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.QIANG));  // 壬+酉：身强（生我。酉生壬→金生水）
            put(Arrays.asList(Constant.REN_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.RUO));     // 壬+戌：身弱（克我。戌克壬→土克水）
            put(Arrays.asList(Constant.REN_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.QIANG));  // 壬+亥：身强（同我。壬同亥→水同水）

            put(Arrays.asList(Constant.GUI_GAN, Constant.ZI_ZHI), Collections.singletonList(Constant.QIANG));   // 癸+子：身强（同我。癸同子→水同水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.CHOU_ZHI), Collections.singletonList(Constant.RUO));   // 癸+丑：身弱（克我。丑克癸→土克水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.YIN_ZHI), Collections.singletonList(Constant.RUO));    // 癸+寅：身弱（我生。寅生癸→水生木）
            put(Arrays.asList(Constant.GUI_GAN, Constant.MAO_ZHI), Collections.singletonList(Constant.RUO));    // 癸+卯：身弱（我生。卯生癸→水生木）
            put(Arrays.asList(Constant.GUI_GAN, Constant.CHEN_ZHI), Collections.singletonList(Constant.RUO));   // 癸+辰：身弱（克我。辰克癸→土克水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.SI_ZHI), Collections.singletonList(Constant.RUO));     // 癸+巳：身弱（我克。癸克巳→水克火）
            put(Arrays.asList(Constant.GUI_GAN, Constant.WU_ZHI), Collections.singletonList(Constant.RUO));     // 癸+午：身弱（我克。癸克午→水克火）
            put(Arrays.asList(Constant.GUI_GAN, Constant.WEI_ZHI), Collections.singletonList(Constant.RUO));    // 癸+未：身弱（克我。未克癸→土克水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.SHEN_ZHI), Collections.singletonList(Constant.QIANG)); // 癸+申：身强（生我。申生癸→金生水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.YOU_ZHI), Collections.singletonList(Constant.QIANG));  // 癸+酉：身强（生我。酉生癸→金生水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.XU_ZHI), Collections.singletonList(Constant.RUO));     // 癸+戌：身弱（克我。戌克癸→土克水）
            put(Arrays.asList(Constant.GUI_GAN, Constant.HAI_ZHI), Collections.singletonList(Constant.QIANG));  // 癸+亥：身强（同我。癸同亥→水同水）

        }

    };

    /**
     * 五行对应方位
     */
    public static final Map<String, List<String>> WU_XING_FANG_WEI = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        {
            put(Constant.MU, Arrays.asList(Constant.DONG, Constant.DONG_NAN));   // 木：东、东南
            put(Constant.HUO, Collections.singletonList(Constant.NAN));          // 火：南
            put(Constant.TU, Arrays.asList(Constant.XI_NAN, Constant.DONG_BEI)); // 土：西南、东北
            put(Constant.JIN, Arrays.asList(Constant.XI, Constant.XI_BEI));      // 金：西、西北
            put(Constant.SHUI, Collections.singletonList(Constant.BEI));         // 水：北
        }

    };

    /**
     * 太极贵人
     */
    public static final Map<String, List<String>> TAI_JI_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【计算太极贵人】算法↓

                1、年干或日干是'甲'或者'乙'，并且其他地支有'子'或者'午'的，则为太极贵人；
                2、年干或日干是'丙'或者'丁'，并且其他地支有'酉'或者'卯'的，则为太极贵人；
                3、年干或日干是'庚'或者'辛'，并且其他地支有'寅'或者'亥'的，则为太极贵人；
                4、年干或日干是'壬'或者'癸'，并且其他地支有'巳'或者'申'的，则为太极贵人；
                5、年干或日干是'戊'或者'己'，并且其他地支有'辰'或者'戌'或者'丑'或者'未'的，则为太极贵人。
         */

        {
            put(Constant.JIA_GAN, Arrays.asList(Constant.ZI_ZHI, Constant.WU_ZHI));    // 年干或日干是'甲'，并且其他地支有'子'或者'午'的，则为太极贵人。
            put(Constant.YI_GAN, Arrays.asList(Constant.ZI_ZHI, Constant.WU_ZHI));     // 年干或日干是'乙'，并且其他地支有'子'或者'午'的，则为太极贵人。
            put(Constant.BING_GAN, Arrays.asList(Constant.YOU_ZHI, Constant.MAO_ZHI)); // 年干或日干是'丙'，并且其他地支有'酉'或者'卯'的，则为太极贵人。
            put(Constant.DING_GAN, Arrays.asList(Constant.YOU_ZHI, Constant.MAO_ZHI)); // 年干或日干是'丁'，并且其他地支有'酉'或者'卯'的，则为太极贵人。
            put(Constant.WU_GAN, Arrays.asList(Constant.CHEN_ZHI, Constant.XU_ZHI, Constant.CHOU_ZHI, Constant.WEI_ZHI)); // 年干或日干是'戊'，并且其他地支有'辰'或者'戌'或者'丑'或者'未'的，则为太极贵人。
            put(Constant.JI_GAN, Arrays.asList(Constant.CHEN_ZHI, Constant.XU_ZHI, Constant.CHOU_ZHI, Constant.WEI_ZHI)); // 年干或日干是'己'，并且其他地支有'辰'或者'戌'或者'丑'或者'未'的，则为太极贵人。
            put(Constant.GENG_GAN, Arrays.asList(Constant.YIN_ZHI, Constant.HAI_ZHI)); // 年干或日干是'庚'，并且其他地支有'寅'或者'亥'的，则为太极贵人。
            put(Constant.XIN_GAN, Arrays.asList(Constant.YIN_ZHI, Constant.HAI_ZHI));  // 年干或日干是'辛'，并且其他地支有'寅'或者'亥'的，则为太极贵人。
            put(Constant.REN_GAN, Arrays.asList(Constant.SI_ZHI, Constant.SHEN_ZHI));  // 年干或日干是'壬'，并且其他地支有'巳'或者'申'的，则为太极贵人。
            put(Constant.GUI_GAN, Arrays.asList(Constant.SI_ZHI, Constant.SHEN_ZHI));  // 年干或日干是'癸'，并且其他地支有'巳'或者'申'的，则为太极贵人。
        }

    };

    /**
     * 天乙贵人
     */
    public static final Map<String, List<String>> TIAN_YI_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【天乙贵人】算法↓

                1、年干或日干是甲，并且其他地支有'丑'或者'未'的，则为天乙贵人；
                2、年干或日干是乙，并且其他地支有'子'或者'申'的，则为天乙贵人；
                3、年干或日干是丙，并且其他地支有'酉'或者'亥'的，则为天乙贵人；
                4、年干或日干是丁，并且其他地支有'酉'或者'亥'的，则为天乙贵人；
                5、年干或日干是戊，并且其他地支有'丑'或者'未'的，则为天乙贵人；
                6、年干或日干是己，并且其他地支有'子'或者'申'的，则为天乙贵人；
                7、年干或日干是庚，并且其他地支有'丑'或者'未'的，则为天乙贵人；
                8、年干或日干是辛，并且其他地支有'寅'或者'午'的，则为天乙贵人；
                9、年干或日干是壬，并且其他地支有'卯'或者'巳'的，则为天乙贵人；
                10、年干或日干是癸，并且其他地支有'卯'或者'巳'的，则为天乙贵人。
         */

        {
            put(Constant.JIA_GAN, Arrays.asList(Constant.CHOU_ZHI, Constant.WEI_ZHI));  // 年干或日干是甲，并且其他地支有'丑'或者'未'的，则为天乙贵人。
            put(Constant.YI_GAN, Arrays.asList(Constant.ZI_ZHI, Constant.SHEN_ZHI));    // 年干或日干是乙，并且其他地支有'子'或者'申'的，则为天乙贵人。
            put(Constant.BING_GAN, Arrays.asList(Constant.YOU_ZHI, Constant.HAI_ZHI));  // 年干或日干是丙，并且其他地支有'酉'或者'亥'的，则为天乙贵人。
            put(Constant.DING_GAN, Arrays.asList(Constant.YOU_ZHI, Constant.HAI_ZHI));  // 年干或日干是丁，并且其他地支有'酉'或者'亥'的，则为天乙贵人。
            put(Constant.WU_GAN, Arrays.asList(Constant.CHOU_ZHI, Constant.WEI_ZHI));   // 年干或日干是戊，并且其他地支有'丑'或者'未'的，则为天乙贵人。
            put(Constant.JI_GAN, Arrays.asList(Constant.ZI_ZHI, Constant.SHEN_ZHI));    // 年干或日干是己，并且其他地支有'子'或者'申'的，则为天乙贵人。
            put(Constant.GENG_GAN, Arrays.asList(Constant.CHOU_ZHI, Constant.WEI_ZHI)); // 年干或日干是庚，并且其他地支有'丑'或者'未'的，则为天乙贵人。
            put(Constant.XIN_GAN, Arrays.asList(Constant.YIN_ZHI, Constant.WU_ZHI));    // 年干或日干是辛，并且其他地支有'寅'或者'午'的，则为天乙贵人。
            put(Constant.REN_GAN, Arrays.asList(Constant.MAO_ZHI, Constant.SI_ZHI));    // 年干或日干是壬，并且其他地支有'卯'或者'巳'的，则为天乙贵人。
            put(Constant.GUI_GAN, Arrays.asList(Constant.MAO_ZHI, Constant.SI_ZHI));    // 年干或日干是癸，并且其他地支有'卯'或者'巳'的，则为天乙贵人。
        }

    };

    /**
     * 文昌贵人
     */
    public static final Map<String, String> WEN_CHANG_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【文昌贵人】算法↓

                1、年干或日干是甲，并且其他地支有'巳'的，则为文昌贵人；
                2、年干或日干是乙，并且其他地支有'午'的，则为文昌贵人；
                3、年干或日干是丙，并且其他地支有'申'的，则为文昌贵人；
                4、年干或日干是丁，并且其他地支有'酉'的，则为文昌贵人；
                5、年干或日干是戊，并且其他地支有'申'的，则为文昌贵人；
                6、年干或日干是己，并且其他地支有'酉'的，则为文昌贵人；
                7、年干或日干是庚，并且其他地支有'亥'的，则为文昌贵人；
                8、年干或日干是辛，并且其他地支有'子'的，则为文昌贵人；
                9、年干或日干是壬，并且其他地支有'寅'的，则为文昌贵人；
                10、年干或日干是癸，并且其他地支有'卯'的，则为文昌贵人。
         */

        {
            put(Constant.JIA_GAN, Constant.SI_ZHI);    // 年干或日干是'甲'，则文昌贵人在'巳'。
            put(Constant.YI_GAN, Constant.WU_ZHI);     // 年干或日干是'乙'，则文昌贵人在'午'。
            put(Constant.BING_GAN, Constant.SHEN_ZHI); // 年干或日干是'丙'，则文昌贵人在'申'。
            put(Constant.DING_GAN, Constant.YOU_ZHI);  // 年干或日干是'丁'，则文昌贵人在'酉'。
            put(Constant.WU_GAN, Constant.SHEN_ZHI);   // 年干或日干是'戊'，则文昌贵人在'申'。
            put(Constant.JI_GAN, Constant.YOU_ZHI);    // 年干或日干是'己'，则文昌贵人在'酉'。
            put(Constant.GENG_GAN, Constant.HAI_ZHI);  // 年干或日干是'庚'，则文昌贵人在'亥'。
            put(Constant.XIN_GAN, Constant.ZI_ZHI);    // 年干或日干是'辛'，则文昌贵人在'子'。
            put(Constant.REN_GAN, Constant.YIN_ZHI);   // 年干或日干是'壬'，则文昌贵人在'寅'。
            put(Constant.GUI_GAN, Constant.MAO_ZHI);   // 年干或日干是'癸'，则文昌贵人在'卯'。
        }

    };

    /**
     * 天厨贵人
     */
    public static final Map<String, String> TIAN_CHU_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天厨贵人】算法↓

                1、年干或日干是甲，并且其他地支有'巳'的，则为天厨贵人；
                2、年干或日干是乙，并且其他地支有'午'的，则为天厨贵人；
                3、年干或日干是丙，并且其他地支有'巳'的，则为天厨贵人；
                4、年干或日干是丁，并且其他地支有'午'的，则为天厨贵人；
                5、年干或日干是戊，并且其他地支有'申'的，则为天厨贵人；
                6、年干或日干是己，并且其他地支有'酉'的，则为天厨贵人；
                7、年干或日干是庚，并且其他地支有'亥'的，则为天厨贵人；
                8、年干或日干是辛，并且其他地支有'子'的，则为天厨贵人；
                9、年干或日干是壬，并且其他地支有'寅'的，则为天厨贵人；
                10、年干或日干是癸，并且其他地支有'卯'的，则为天厨贵人。
         */

        {
            put(Constant.JIA_GAN, Constant.SI_ZHI);   // 年干或日干是'甲'，则天厨贵人在'巳'。
            put(Constant.YI_GAN, Constant.WU_ZHI);    // 年干或日干是'乙'，则天厨贵人在'午'。
            put(Constant.BING_GAN, Constant.ZI_ZHI);  // 年干或日干是'丙'，则天厨贵人在'巳'。
            put(Constant.DING_GAN, Constant.WU_ZHI);  // 年干或日干是'丁'，则天厨贵人在'午'。
            put(Constant.WU_GAN, Constant.SHEN_ZHI);  // 年干或日干是'戊'，则天厨贵人在'申'。
            put(Constant.JI_GAN, Constant.YOU_ZHI);   // 年干或日干是'己'，则天厨贵人在'酉'。
            put(Constant.GENG_GAN, Constant.HAI_ZHI); // 年干或日干是'庚'，则天厨贵人在'亥'。
            put(Constant.XIN_GAN, Constant.ZI_ZHI);   // 年干或日干是'辛'，则天厨贵人在'子'。
            put(Constant.REN_GAN, Constant.YIN_ZHI);  // 年干或日干是'壬'，则天厨贵人在'寅'。
            put(Constant.GUI_GAN, Constant.MAO_ZHI);  // 年干或日干是'癸'，则天厨贵人在'卯'。
        }

    };

    /**
     * 福星贵人
     */
    public static final Map<String, List<String>> FU_XING_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【福星贵人】算法↓

                1、年干或日干是甲，并且其他地支有'寅'或者'子'的，则为福星贵人；
                2、年干或日干是乙，并且其他地支有'卯'或者'丑'的，则为福星贵人；
                3、年干或日干是丙，并且其他地支有'寅'或者'子'的，则为福星贵人；
                4、年干或日干是丁，并且其他地支有'亥'的，则为福星贵人；
                5、年干或日干是戊，并且其他地支有'申'的，则为福星贵人；
                6、年干或日干是己，并且其他地支有'未'的，则为福星贵人；
                7、年干或日干是庚，并且其他地支有'午'的，则为福星贵人；
                8、年干或日干是辛，并且其他地支有'巳'的，则为福星贵人；
                9、年干或日干是壬，并且其他地支有'辰'的，则为福星贵人;
                10、年干或日干是癸，并且其他地支有'卯'或者'丑'的，则为福星贵人；
         */

        {
            put(Constant.JIA_GAN, Arrays.asList(Constant.YIN_ZHI, Constant.ZI_ZHI));   // 年干或日干是甲，并且其他地支有'寅'或者'子'的，则为福星贵人。
            put(Constant.YI_GAN, Arrays.asList(Constant.MAO_ZHI, Constant.CHOU_ZHI));  // 年干或日干是乙，并且其他地支有'卯'或者'丑'的，则为福星贵人。
            put(Constant.BING_GAN, Arrays.asList(Constant.YIN_ZHI, Constant.ZI_ZHI));  // 年干或日干是丙，并且其他地支有'寅'或者'子'的，则为福星贵人。
            put(Constant.DING_GAN, Collections.singletonList(Constant.HAI_ZHI));       // 年干或日干是丁，并且其他地支有'亥'的，则为福星贵人。
            put(Constant.WU_GAN, Collections.singletonList(Constant.SHEN_ZHI));        // 年干或日干是戊，并且其他地支有'申'的，则为福星贵人。
            put(Constant.JI_GAN, Collections.singletonList(Constant.WEI_ZHI));         // 年干或日干是己，并且其他地支有'未'的，则为福星贵人。
            put(Constant.GENG_GAN, Collections.singletonList(Constant.WU_ZHI));        // 年干或日干是庚，并且其他地支有'午'的，则为福星贵人。
            put(Constant.XIN_GAN, Collections.singletonList(Constant.SI_ZHI));         // 年干或日干是辛，并且其他地支有'巳'的，则为福星贵人。
            put(Constant.REN_GAN, Collections.singletonList(Constant.CHEN_ZHI));       // 年干或日干是壬，并且其他地支有'辰'的，则为福星贵人。
            put(Constant.GUI_GAN, Arrays.asList(Constant.MAO_ZHI, Constant.CHOU_ZHI)); // 年干或日干是癸，并且其他地支有'卯'或者'丑'的，则为福星贵人。
        }

    };

    /**
     * 天德贵人
     */
    public static final Map<String, String> TIAN_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天德贵人】算法↓

                1、月支是子，并且其他天干或地支有'巳'的，则为天德贵人；
                2、月支是丑，并且其他天干或地支有'庚'的，则为天德贵人；
                3、月支是寅，并且其他天干或地支有'丁'的，则为天德贵人；
                4、月支是卯，并且其他天干或地支有'申'的，则为天德贵人；
                5、月支是辰，并且其他天干或地支有'壬'的，则为天德贵人；
                6、月支是巳，并且其他天干或地支有'辛'的，则为天德贵人；
                7、月支是午，并且其他天干或地支有'亥'的，则为天德贵人；
                8、月支是未，并且其他天干或地支有'甲'的，则为天德贵人；
                9、月支是申，并且其他天干或地支有'癸'的，则为天德贵人；
                10、月支是酉，并且其他天干或地支有'寅'的，则为天德贵人；
                11、月支是戌，并且其他天干或地支有'丙'的，则为天德贵人；
                12、月支是亥，并且其他天干或地支有'乙'的，则为天德贵人。
         */

        {
            put(Constant.ZI_ZHI, Constant.SI_ZHI);     // 年支或日支是'子'，并且其他天干或地支有'巳'的，则为天德贵人；
            put(Constant.CHOU_ZHI, Constant.GENG_GAN); // 年支或日支是'丑'，并且其他天干或地支有'庚'的，则为天德贵人；
            put(Constant.YIN_ZHI, Constant.DING_GAN);  // 年支或日支是'寅'，并且其他天干或地支有'丁'的，则为天德贵人；
            put(Constant.MAO_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'卯'，并且其他天干或地支有'申'的，则为天德贵人；
            put(Constant.CHEN_ZHI, Constant.REN_GAN);  // 年支或日支是'辰'，并且其他天干或地支有'壬'的，则为天德贵人；
            put(Constant.SI_ZHI, Constant.XIN_GAN);    // 年支或日支是'巳'，并且其他天干或地支有'辛'的，则为天德贵人；
            put(Constant.WU_ZHI, Constant.HAI_ZHI);    // 年支或日支是'午'，并且其他天干或地支有'亥'的，则为天德贵人；
            put(Constant.WEI_ZHI, Constant.JIA_GAN);   // 年支或日支是'未'，并且其他天干或地支有'甲'的，则为天德贵人；
            put(Constant.SHEN_ZHI, Constant.GUI_GAN);  // 年支或日支是'申'，并且其他天干或地支有'癸'的，则为天德贵人；
            put(Constant.YOU_ZHI, Constant.YIN_ZHI);   // 年支或日支是'酉'，并且其他天干或地支有'寅'的，则为天德贵人；
            put(Constant.XU_ZHI, Constant.BING_GAN);   // 年支或日支是'戌'，并且其他天干或地支有'丙'的，则为天德贵人；
            put(Constant.HAI_ZHI, Constant.YI_GAN);    // 年支或日支是'亥'，并且其他天干或地支有'乙'的，则为天德贵人；
        }

    };

    /**
     * 月德贵人
     */
    public static final Map<String, String> YUE_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【月德贵人】算法↓

                1、月支是申、子、辰，并且其他天干是'壬'的，则为月德贵人。
                2、月支是寅、午、戌，并且其他天干是'丙'的，则为月德贵人。
                3、月支是亥、卯、未，并且其他天干是'甲'的，则为月德贵人。
                4、月支是巳、酉、丑，并且其他天干是'庚'的，则为月德贵人。
         */

        {
            put(Constant.ZI_ZHI, Constant.REN_GAN);    // 月支是'子'，并且其他天干是'壬'的，则为月德贵人。
            put(Constant.CHOU_ZHI, Constant.GENG_GAN); // 月支是'丑'，并且其他天干是'庚'的，则为月德贵人。
            put(Constant.YIN_ZHI, Constant.BING_GAN);  // 月支是'寅'，并且其他天干是'丙'的，则为月德贵人。
            put(Constant.MAO_ZHI, Constant.JIA_GAN);   // 月支是'卯'，并且其他天干是'甲'的，则为月德贵人。
            put(Constant.CHEN_ZHI, Constant.REN_GAN);  // 月支是'辰'，并且其他天干是'壬'的，则为月德贵人。
            put(Constant.SI_ZHI, Constant.GENG_GAN);   // 月支是'巳'，并且其他天干是'庚'的，则为月德贵人。
            put(Constant.WU_ZHI, Constant.BING_GAN);   // 月支是'午'，并且其他天干是'丙'的，则为月德贵人。
            put(Constant.WEI_ZHI, Constant.JIA_GAN);   // 月支是'未'，并且其他天干是'甲'的，则为月德贵人。
            put(Constant.SHEN_ZHI, Constant.REN_GAN);  // 月支是'申'，并且其他天干是'壬'的，则为月德贵人。
            put(Constant.YOU_ZHI, Constant.GENG_GAN);  // 月支是'酉'，并且其他天干是'庚'的，则为月德贵人。
            put(Constant.XU_ZHI, Constant.BING_GAN);   // 月支是'戌'，并且其他天干是'丙'的，则为月德贵人。
            put(Constant.HAI_ZHI, Constant.JIA_GAN);   // 月支是'亥'，并且其他天干是'甲'的，则为月德贵人。
        }

    };

    /**
     * 德秀贵人
     */
    public static final Map<String, List<String>> DE_XIU_GUI_REN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【德秀贵人】算法↓

                1、月支是子，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'的，则为德秀贵人。
                2、月支是丑，并且其他天干有'乙'或者'庚'或者'辛'的，则为德秀贵人。
                3、月支是寅，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'的，则为德秀贵人。
                4、月支是卯，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'的，则为德秀贵人。
                5、月支是辰，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'的，则为德秀贵人。
                6、月支是巳，并且其他天干有'乙'或者'庚'或者'辛'的，则为德秀贵人。
                7、月支是午，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'的，则为德秀贵人。
                8、月支是未，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'的，则为德秀贵人。
                9、月支是申，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'的，则为德秀贵人。
                10、月支是酉，并且其他天干有'乙'或者'庚'或者'辛'的，则为德秀贵人。
                11、月支是戌，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'的，则为德秀贵人。
                12、月支是亥，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'的，则为德秀贵人。
         */

        {
            put(Constant.ZI_ZHI, Arrays.asList(Constant.JIA_GAN, Constant.BING_GAN, Constant.WU_GAN, Constant.JI_GAN, Constant.XIN_GAN, Constant.REN_GAN, Constant.GUI_GAN)); // 月支是子，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'的，则为德秀贵人。
            put(Constant.CHOU_ZHI, Arrays.asList(Constant.YI_GAN, Constant.GENG_GAN, Constant.XIN_GAN)); // 月支是丑，并且其他天干有'乙'或者'庚'或者'辛'的，则为德秀贵人。
            put(Constant.YIN_ZHI, Arrays.asList(Constant.BING_GAN, Constant.DING_GAN, Constant.WU_GAN, Constant.GUI_GAN)); // 月支是寅，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'的，则为德秀贵人。
            put(Constant.MAO_ZHI, Arrays.asList(Constant.JIA_GAN, Constant.YI_GAN, Constant.DING_GAN, Constant.REN_GAN)); // 月支是卯，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'的，则为德秀贵人。
            put(Constant.CHEN_ZHI, Arrays.asList(Constant.JIA_GAN, Constant.BING_GAN, Constant.WU_GAN, Constant.JI_GAN, Constant.XIN_GAN, Constant.REN_GAN, Constant.GUI_GAN)); // 月支是辰，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'的，则为德秀贵人。
            put(Constant.SI_ZHI, Arrays.asList(Constant.YI_GAN, Constant.GENG_GAN, Constant.XIN_GAN)); // 月支是巳，并且其他天干有'乙'或者'庚'或者'辛'的，则为德秀贵人。
            put(Constant.WU_ZHI, Arrays.asList(Constant.BING_GAN, Constant.DING_GAN, Constant.WU_GAN, Constant.GUI_GAN)); // 月支是午，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'的，则为德秀贵人。
            put(Constant.WEI_ZHI, Arrays.asList(Constant.JIA_GAN, Constant.YI_GAN, Constant.DING_GAN, Constant.REN_GAN)); // 月支是未，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'的，则为德秀贵人。
            put(Constant.SHEN_ZHI, Arrays.asList(Constant.JIA_GAN, Constant.BING_GAN, Constant.WU_GAN, Constant.JI_GAN, Constant.XIN_GAN, Constant.REN_GAN, Constant.GUI_GAN)); // 月支是申，并且其他天干有'甲'或者'丙'或者'戊'或者'己'或者'辛'或者'壬'或者'癸'的，则为德秀贵人。
            put(Constant.YOU_ZHI, Arrays.asList(Constant.YI_GAN, Constant.GENG_GAN, Constant.XIN_GAN)); // 月支是酉，并且其他天干有'乙'或者'庚'或者'辛'的，则为德秀贵人。
            put(Constant.XU_ZHI, Arrays.asList(Constant.BING_GAN, Constant.DING_GAN, Constant.WU_GAN, Constant.GUI_GAN)); // 月支是戌，并且其他天干有'丙'或者'丁'或者'戊'或者'癸'的，则为德秀贵人。
            put(Constant.HAI_ZHI, Arrays.asList(Constant.JIA_GAN, Constant.YI_GAN, Constant.DING_GAN, Constant.REN_GAN)); // 月支是亥，并且其他天干有'甲'或者'乙'或者'丁'或者'壬'的，则为德秀贵人。
        }

    };

    /**
     * 三奇贵人
     */
    public static final String[] SAN_QI_GUI_REN = {"甲戊庚", "乙丙丁", "壬癸辛", "庚戊甲", "丁丙乙", "辛癸壬"};

    /**
     * 阴差阳错
     */
    public static final String[] YIN_CHA_YANG_CUO = {"丙午", "丙子", "丁未", "丁丑", "戊申", "戊寅", "辛酉", "辛卯", "壬戌", "壬辰", "癸巳", "癸亥"};

    /**
     * 十恶大败
     */
    public static final String[] SHI_E_DA_BAI = {"甲辰", "乙巳", "丙申", "丁亥", "戊戌", "己丑", "庚辰", "辛巳", "壬申", "癸亥"};

    /**
     * 孤鸾煞
     */
    public static final String[] GU_LUAN_SHA = {"乙巳", "丁巳", "辛亥", "戊申", "甲寅", "丙午", "戊午", "壬子"};

    /**
     * 六秀日
     */
    public static final String[] LIU_XIU = {"丙午", "丁未", "戊子", "戊午", "己丑", "己未"};

    /**
     * 十灵日
     */
    public static final String[] SHI_LING = {"甲辰", "乙亥", "丙辰", "丁酉", "戊午", "庚戌", "庚寅", "辛亥", "壬寅", "癸未"};

    /**
     * 红艳煞
     */
    public static final Map<String, String> HONG_YAN_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【红艳煞】算法↓

                1、日干为甲，并且其他地支有'午'的，为红艳煞。
                2、日干是乙，并且其他地支有'申'的，为红艳煞。
                3、日干是丙，并且其他地支有'寅'的，为红艳煞。
                4、日干是丁，并且其他地支有'未'的，为红艳煞。
                5、日干是戊，并且其他地支有'辰'的，为红艳煞。
                6、日干是己，并且其他地支有'辰'的，为红艳煞。
                7、日干是庚，并且其他地支有'戌'的，为红艳煞。
                8、日干是辛，并且其他地支有'酉'的，为红艳煞。
                9、日干是壬，并且其他地支有'子'的，为红艳煞。
                10、日干为癸，并且其他地支有'申'的，为红艳煞。
         */

        {
            put(Constant.JIA_GAN, Constant.WU_ZHI);   // 日干为甲，并且其他天干有'午'的，为红艳煞。
            put(Constant.YI_GAN, Constant.SHEN_ZHI);  // 日干是乙，并且其他天干有'申'的，为红艳煞。
            put(Constant.BING_GAN, Constant.YIN_ZHI); // 日干是丙，并且其他天干有'寅'的，为红艳煞。
            put(Constant.DING_GAN, Constant.WEI_ZHI); // 日干是丁，并且其他天干有'未'的，为红艳煞。
            put(Constant.WU_GAN, Constant.CHEN_ZHI);  // 日干是戊，并且其他天干有'辰'的，为红艳煞。
            put(Constant.JI_GAN, Constant.CHEN_ZHI);  // 日干是己，并且其他天干有'辰'的，为红艳煞。
            put(Constant.GENG_GAN, Constant.XU_ZHI);  // 日干是庚，并且其他天干有'戌'的，为红艳煞。
            put(Constant.XIN_GAN, Constant.YOU_ZHI);  // 日干是辛，并且其他天干有'酉'的，为红艳煞。
            put(Constant.REN_GAN, Constant.ZI_ZHI);   // 日干是壬，并且其他天干有'子'的，为红艳煞。
            put(Constant.GUI_GAN, Constant.SHEN_ZHI); // 日干为癸，并且其他天干有'申'的，为红艳煞。
        }

    };

    /**
     * 驿马
     */
    public static final Map<String, String> YI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【驿马】算法↓

                1、年支或日支是申、子、辰，并且其他地支有'寅'的，则为驿马。
                2、年支或日支是寅、午、戌，并且其他地支有'申'的，则为驿马。
                3、年支或日支是亥、卯、未，并且其他地支有'巳'的，则为驿马。
                4、年支或日支是巳、酉、丑，并且其他地支有'亥'的，则为驿马。
         */

        {
            put(Constant.ZI_ZHI, Constant.YIN_ZHI);   // 年支或日支是'子'，则驿马在'寅'。
            put(Constant.CHOU_ZHI, Constant.HAI_ZHI); // 年支或日支是'丑'，则驿马在'亥'。
            put(Constant.YIN_ZHI, Constant.SHEN_ZHI); // 年支或日支是'寅'，则驿马在'申'。
            put(Constant.MAO_ZHI, Constant.SI_ZHI);   // 年支或日支是'卯'，则驿马在'巳'。
            put(Constant.CHEN_ZHI, Constant.YIN_ZHI); // 年支或日支是'辰'，则驿马在'寅'。
            put(Constant.SI_ZHI, Constant.HAI_ZHI);   // 年支或日支是'巳'，则驿马在'亥'。
            put(Constant.WU_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'午'，则驿马在'申'。
            put(Constant.WEI_ZHI, Constant.SI_ZHI);   // 年支或日支是'未'，则驿马在'巳'。
            put(Constant.SHEN_ZHI, Constant.YIN_ZHI); // 年支或日支是'申'，则驿马在'寅'。
            put(Constant.YOU_ZHI, Constant.HAI_ZHI);  // 年支或日支是'酉'，则驿马在'亥'。
            put(Constant.XU_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'戌'，则驿马在'申'。
            put(Constant.HAI_ZHI, Constant.SI_ZHI);   // 年支或日支是'亥'，则驿马在'巳'。
        }

    };

    /**
     * 华盖
     */
    public static final Map<String, String> HUA_GAI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【华盖】算法↓

                1、年支或日支是申、子、辰，并且其他地支有'辰'的，则为华盖。
                2、年支或日支是寅、午、戌，并且其他地支有'戌'的，则为华盖。
                3、年支或日支是巳、酉、丑，并且其他地支有'丑'的，则为华盖。
                4、年支或日支是亥、卯、未，并且其他地支有'未'的，则为华盖。
         */

        {
            put(Constant.ZI_ZHI, Constant.CHEN_ZHI);   // 年支或日支是'子'，则华盖在'辰'。
            put(Constant.CHOU_ZHI, Constant.CHOU_ZHI); // 年支或日支是'丑'，则华盖在'丑'。
            put(Constant.YIN_ZHI, Constant.XU_ZHI);    // 年支或日支是'寅'，则华盖在'戌'。
            put(Constant.MAO_ZHI, Constant.WEI_ZHI);   // 年支或日支是'卯'，则华盖在'未'。
            put(Constant.CHEN_ZHI, Constant.CHEN_ZHI); // 年支或日支是'辰'，则华盖在'辰'。
            put(Constant.SI_ZHI, Constant.CHOU_ZHI);   // 年支或日支是'巳'，则华盖在'丑'。
            put(Constant.WU_ZHI, Constant.XU_ZHI);     // 年支或日支是'午'，则华盖在'戌'。
            put(Constant.WEI_ZHI, Constant.WEI_ZHI);   // 年支或日支是'未'，则华盖在'未'。
            put(Constant.SHEN_ZHI, Constant.CHEN_ZHI); // 年支或日支是'申'，则华盖在'辰'。
            put(Constant.YOU_ZHI, Constant.CHOU_ZHI);  // 年支或日支是'酉'，则华盖在'丑'。
            put(Constant.XU_ZHI, Constant.XU_ZHI);     // 年支或日支是'戌'，则华盖在'戌'。
            put(Constant.HAI_ZHI, Constant.WEI_ZHI);   // 年支或日支是'亥'，则华盖在'未'。
        }

    };

    /**
     * 天医
     */
    public static final Map<String, String> TIAN_YI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天医】算法↓

                1、月支为子，并且其他地支有'亥'的，则为天医。
                2、月支为丑，并且其他地支有'子'的，则为天医。
                3、月支为寅，并且其他地支有'丑'的，则为天医。
                4、月支为卯，并且其他地支有'寅'的，则为天医。
                5、月支为辰，并且其他地支有'卯'的，则为天医。
                6、月支为巳，并且其他地支有'辰'的，则为天医。
                7、月支为午，并且其他地支有'巳'的，则为天医。
                8、月支为未，并且其他地支有'午'的，则为天医。
                9、月支为申，并且其他地支有'未'的，则为天医。
                10、月支为酉，并且其他地支有'申'的，则为天医。
                11、月支为戌，并且其他地支有'酉'的，则为天医。
                12、月支为亥，并且其他地支有'戌'的，则为天医。
         */

        {
            put(Constant.ZI_ZHI, Constant.HAI_ZHI);   // 日地支为'子'，则天医在'亥'。
            put(Constant.CHOU_ZHI, Constant.ZI_ZHI);  // 日地支为'丑'，则天医在'子'。
            put(Constant.YIN_ZHI, Constant.CHOU_ZHI); // 日地支为'寅'，则天医在'丑'。
            put(Constant.MAO_ZHI, Constant.YIN_ZHI);  // 日地支为'卯'，则天医在'寅'。
            put(Constant.CHEN_ZHI, Constant.MAO_ZHI); // 日地支为'辰'，则天医在'卯'。
            put(Constant.SI_ZHI, Constant.CHEN_ZHI);  // 日地支为'巳'，则天医在'辰'。
            put(Constant.WU_ZHI, Constant.SI_ZHI);    // 日地支为'午'，则天医在'巳'。
            put(Constant.WEI_ZHI, Constant.WU_ZHI);   // 日地支为'未'，则天医在'午'。
            put(Constant.SHEN_ZHI, Constant.WEI_ZHI); // 日地支为'申'，则天医在'未'。
            put(Constant.YOU_ZHI, Constant.SHEN_ZHI); // 日地支为'酉'，则天医在'申'。
            put(Constant.XU_ZHI, Constant.YOU_ZHI);   // 日地支为'戌'，则天医在'酉'。
            put(Constant.HAI_ZHI, Constant.XU_ZHI);   // 日地支为'亥'，则天医在'戌'。
        }

    };

    /**
     * 劫煞
     */
    public static final Map<String, String> JIE_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【劫煞】算法↓

                1、年支或日支是巳、酉、丑，并且其他地支有'寅'的，则为劫煞。
                2、年支或日支是亥、卯、未，并且其他地支有'申'的，则为劫煞。
                3、年支或日支是申、子、辰，并且其他地支有'巳'的，则为劫煞。
                4、年支或日支是寅、午、戌，并且其他地支有'亥'的，则为劫煞。
        */

        {
            put(Constant.ZI_ZHI, Constant.SI_ZHI);    // 日地支为'子'，则劫煞在'巳'。
            put(Constant.CHOU_ZHI, Constant.YIN_ZHI); // 日地支为'丑'，则劫煞在'寅'。
            put(Constant.YIN_ZHI, Constant.HAI_ZHI);  // 日地支为'寅'，则劫煞在'亥'。
            put(Constant.MAO_ZHI, Constant.SHEN_ZHI); // 日地支为'卯'，则劫煞在'申'。
            put(Constant.CHEN_ZHI, Constant.SI_ZHI);  // 日地支为'辰'，则劫煞在'巳'。
            put(Constant.SI_ZHI, Constant.YIN_ZHI);   // 日地支为'巳'，则劫煞在'寅'。
            put(Constant.WU_ZHI, Constant.HAI_ZHI);   // 日地支为'午'，则劫煞在'亥'。
            put(Constant.WEI_ZHI, Constant.SHEN_ZHI); // 日地支为'未'，则劫煞在'申'。
            put(Constant.SHEN_ZHI, Constant.SI_ZHI);  // 日地支为'申'，则劫煞在'巳'。
            put(Constant.YOU_ZHI, Constant.YIN_ZHI);  // 日地支为'酉'，则劫煞在'寅'。
            put(Constant.XU_ZHI, Constant.HAI_ZHI);   // 日地支为'戌'，则劫煞在'亥'。
            put(Constant.HAI_ZHI, Constant.SHEN_ZHI); // 日地支为'亥'，则劫煞在'申'。
        }

    };

    /**
     * 将星
     */
    public static final Map<String, String> JIANG_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【将星】算法↓

                1、年支或日支是申、子、辰，并且其他地支有'子'的，则为将星。
                2、年支或日支是寅、午、戌，并且其他地支有'午'的，则为将星。
                3、年支或日支是亥、卯、未，并且其他地支有'卯'的，则为将星。
                4、年支或日支是巳、酉、丑，并且其他地支有'酉'的，则为将星。
         */

        {
            put(Constant.ZI_ZHI, Constant.ZI_ZHI);    // 年支或日支是'子'，则将星在'子'。
            put(Constant.CHOU_ZHI, Constant.YOU_ZHI); // 年支或日支是'丑'，则将星在'酉'。
            put(Constant.YIN_ZHI, Constant.WU_ZHI);   // 年支或日支是'寅'，则将星在'午'。
            put(Constant.MAO_ZHI, Constant.MAO_ZHI);  // 年支或日支是'卯'，则将星在'卯'。
            put(Constant.CHEN_ZHI, Constant.ZI_ZHI);  // 年支或日支是'辰'，则将星在'子'。
            put(Constant.SI_ZHI, Constant.YOU_ZHI);   // 年支或日支是'巳'，则将星在'酉'。
            put(Constant.WU_ZHI, Constant.WU_ZHI);    // 年支或日支是'午'，则将星在'午'。
            put(Constant.WEI_ZHI, Constant.MAO_ZHI);  // 年支或日支是'未'，则将星在'卯'。
            put(Constant.SHEN_ZHI, Constant.ZI_ZHI);  // 年支或日支是'申'，则将星在'子'。
            put(Constant.YOU_ZHI, Constant.YOU_ZHI);  // 年支或日支是'酉'，则将星在'酉'。
            put(Constant.XU_ZHI, Constant.WU_ZHI);    // 年支或日支是'戌'，则将星在'午'。
            put(Constant.HAI_ZHI, Constant.MAO_ZHI);  // 年支或日支是'亥'，则将星在'卯'。
        }

    };

    /**
     * 桃花
     */
    public static final Map<String, String> TAO_HUA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【桃花】算法↓

                1、年支或日支是亥、卯、未，并且其他地支有'子'的，则为桃花。
                2、年支或日支是巳、酉、丑，并且其他地支有'午'的，则为桃花。
                3、年支或日支是寅、午、戌，并且其他地支有'卯'的，则为桃花。
                4、年支或日支是申、子、辰，并且其他地支有'酉'的，则为桃花。
         */

        {
            put(Constant.ZI_ZHI, Constant.YOU_ZHI);   // 年支或日支是'子'，则华盖在'酉'。
            put(Constant.CHOU_ZHI, Constant.WU_ZHI);  // 年支或日支是'丑'，则华盖在'午'。
            put(Constant.YIN_ZHI, Constant.MAO_ZHI);  // 年支或日支是'寅'，则华盖在'卯'。
            put(Constant.MAO_ZHI, Constant.ZI_ZHI);   // 年支或日支是'卯'，则华盖在'子'。
            put(Constant.CHEN_ZHI, Constant.YOU_ZHI); // 年支或日支是'辰'，则华盖在'酉'。
            put(Constant.SI_ZHI, Constant.WU_ZHI);    // 年支或日支是'巳'，则华盖在'午'。
            put(Constant.WU_ZHI, Constant.MAO_ZHI);   // 年支或日支是'午'，则华盖在'卯'。
            put(Constant.WEI_ZHI, Constant.ZI_ZHI);   // 年支或日支是'未'，则华盖在'子'。
            put(Constant.SHEN_ZHI, Constant.YOU_ZHI); // 年支或日支是'申'，则华盖在'酉'。
            put(Constant.YOU_ZHI, Constant.WU_ZHI);   // 年支或日支是'酉'，则华盖在'午'。
            put(Constant.XU_ZHI, Constant.MAO_ZHI);   // 年支或日支是'戌'，则华盖在'卯'。
            put(Constant.HAI_ZHI, Constant.ZI_ZHI);   // 年支或日支是'亥'，则华盖在'子'。
        }

    };

    /**
     * 红鸾
     */
    public static final Map<String, String> HONG_LUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【红鸾】算法↓

                1、年支为子，并且其他地支有'卯'的，则为红鸾。
                2、年支为丑，并且其他地支有'寅'的，则为红鸾。
                3、年支为寅，并且其他地支有'丑'的，则为红鸾。
                4、年支为卯，并且其他地支有'子'的，则为红鸾。
                5、年支为辰，并且其他地支有'亥'的，则为红鸾。
                6、年支为巳，并且其他地支有'戌'的，则为红鸾。
                7、年支为午，并且其他地支有'酉'的，则为红鸾。
                8、年支为未，并且其他地支有'申'的，则为红鸾。
                9、年支为申，并且其他地支有'未'的，则为红鸾。
                10、年支为酉，并且其他地支有'午'的，则为红鸾。
                11、年支为戌，并且其他地支有'巳'的，则为红鸾。
                12、年支为亥，并且其他地支有'辰'的，则为红鸾。
         */

        {
            put(Constant.ZI_ZHI, Constant.MAO_ZHI);   // 年地支为'子'，则红鸾在'卯'。
            put(Constant.CHOU_ZHI, Constant.YIN_ZHI); // 年地支为'丑'，则红鸾在'寅'。
            put(Constant.YIN_ZHI, Constant.CHOU_ZHI); // 年地支为'寅'，则红鸾在'丑'。
            put(Constant.MAO_ZHI, Constant.ZI_ZHI);   // 年地支为'卯'，则红鸾在'子'。
            put(Constant.CHEN_ZHI, Constant.HAI_ZHI); // 年地支为'辰'，则红鸾在'亥'。
            put(Constant.SI_ZHI, Constant.XU_ZHI);    // 年地支为'巳'，则红鸾在'戌'。
            put(Constant.WU_ZHI, Constant.YOU_ZHI);   // 年地支为'午'，则红鸾在'酉'。
            put(Constant.WEI_ZHI, Constant.SHEN_ZHI); // 年地支为'未'，则红鸾在'申'。
            put(Constant.SHEN_ZHI, Constant.WEI_ZHI); // 年地支为'申'，则红鸾在'未'。
            put(Constant.YOU_ZHI, Constant.WU_ZHI);   // 年地支为'酉'，则红鸾在'午'。
            put(Constant.XU_ZHI, Constant.SI_ZHI);    // 年地支为'戌'，则红鸾在'巳'。
            put(Constant.HAI_ZHI, Constant.CHEN_ZHI); // 年地支为'亥'，则红鸾在'辰'。
        }

    };

    /**
     * 国印
     */
    public static final Map<String, String> GUO_YIN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【国印】算法↓

                1、年干或日干为甲，并且其他地支有'戌'的，则为国印。
                2、年干或日干为乙，并且其他地支有'亥'的，则为国印。
                3、年干或日干为丙，并且其他地支有'丑'的，则为国印。
                4、年干或日干为丁，并且其他地支有'寅'的，则为国印。
                5、年干或日干为戊，并且其他地支有'丑'的，则为国印。
                6、年干或日干为己，并且其他地支有'寅'的，则为国印。
                7、年干或日干为庚，并且其他地支有'辰'的，则为国印。
                8、年干或日干为辛，并且其他地支有'巳'的，则为国印。
                9、年干或日干为壬，并且其他地支有'未'的，则为国印。
                10、年干或日干为癸，并且其他地支有'申'的，则为国印。
         */

        {
            put(Constant.JIA_GAN, Constant.XU_ZHI);    // 年干或日干是'甲'，则国印在'戌'。
            put(Constant.YI_GAN, Constant.HAI_ZHI);    // 年干或日干是'乙'，则国印在'亥'。
            put(Constant.BING_GAN, Constant.CHOU_ZHI); // 年干或日干是'丙'，则国印在'丑'。
            put(Constant.DING_GAN, Constant.YIN_ZHI);  // 年干或日干是'丁'，则国印在'寅'。
            put(Constant.WU_GAN, Constant.CHOU_ZHI);   // 年干或日干是'戊'，则国印在'丑'。
            put(Constant.JI_GAN, Constant.YIN_ZHI);    // 年干或日干是'己'，则国印在'寅'。
            put(Constant.GENG_GAN, Constant.CHEN_ZHI); // 年干或日干是'庚'，则国印在'辰'。
            put(Constant.XIN_GAN, Constant.SI_ZHI);    // 年干或日干是'辛'，则国印在'巳'。
            put(Constant.REN_GAN, Constant.WEI_ZHI);   // 年干或日干是'壬'，则国印在'未'。
            put(Constant.GUI_GAN, Constant.SHEN_ZHI);  // 年干或日干是'癸'，则国印在'申'。
        }

    };

    /**
     * 禄神
     */
    public static final Map<String, String> LU_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【禄神】算法↓

                1、日干为甲，并且其他地支有'寅'的，则为禄神。
                2、日干为乙，并且其他地支有'卯'的，则为禄神。
                3、日干为丙，并且其他地支有'巳'的，则为禄神。
                4、日干为丁，并且其他地支有'午'的，则为禄神。
                5、日干为戊，并且其他地支有'巳'的，则为禄神。
                6、日干为己，并且其他地支有'午'的，则为禄神。
                7、日干为庚，并且其他地支有'申'的，则为禄神。
                8、日干为辛，并且其他地支有'酉'的，则为禄神。
                9、日干为壬，并且其他地支有'亥'的，则为禄神。
                10、日干为癸，并且其他地支有'子'的，则为禄神。
         */

        {
            put(Constant.JIA_GAN, Constant.YIN_ZHI);   // 日干为甲，并且其他地支有'寅'的，为禄神。
            put(Constant.YI_GAN, Constant.MAO_ZHI);    // 日干是乙，并且其他地支有'卯'的，为禄神。
            put(Constant.BING_GAN, Constant.SI_ZHI);   // 日干是丙，并且其他地支有'巳'的，为禄神。
            put(Constant.DING_GAN, Constant.WU_ZHI);   // 日干是丁，并且其他地支有'午'的，为禄神。
            put(Constant.WU_GAN, Constant.SI_ZHI);     // 日干是戊，并且其他地支有'巳'的，为禄神。
            put(Constant.JI_GAN, Constant.WU_ZHI);     // 日干是己，并且其他地支有'午'的，为禄神。
            put(Constant.GENG_GAN, Constant.SHEN_ZHI); // 日干是庚，并且其他地支有'申'的，为禄神。
            put(Constant.XIN_GAN, Constant.YOU_ZHI);   // 日干是辛，并且其他地支有'酉'的，为禄神。
            put(Constant.REN_GAN, Constant.HAI_ZHI);   // 日干是壬，并且其他地支有'亥'的，为禄神。
            put(Constant.GUI_GAN, Constant.ZI_ZHI);    // 日干为癸，并且其他地支有'子'的，为禄神。
        }

    };

    /**
     * 学堂
     */
    public static final Map<String, List<String>> XUE_TANG = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【学堂】算法↓

                一、禄命法：（以年柱纳音查月支、日支、时支）
                    1、年柱纳音为木命，月支或日支或时支有'亥'的，则为学堂。（'己亥'为正学堂）
                    2、年柱纳音为火命，月支或日支或时支有'寅'的，则为学堂。（'丙寅'为正学堂）
                    3、年柱纳音为土命，月支或日支或时支有'申'的，则为学堂。（'戊申'为正学堂）
                    4、年柱纳音为金命，月支或日支或时支有'巳'的，则为学堂。（'辛巳'为正学堂）
                    5、年柱纳音为水命，月支或日支或时支有'申'的，则为学堂。（'甲申'为正学堂）


                二、子平法：（以年干、日干查四柱）★
                    1、年干或日干为甲，并且其他天干地支有'已'或者'亥'的，则为学堂。
                    2、年干或日干为乙，并且其他天干地支有'壬'或者'午'的，则为学堂。
                    3、年干或日干为丙，并且其他天干地支有'丙'或者'寅'的，则为学堂。
                    4、年干或日干为丁，并且其他天干地支有'丁'或者'酉'的，则为学堂。
                    5、年干或日干为戊，并且其他天干地支有'戊'或者'寅'的，则为学堂。
                    6、年干或日干为己，并且其他天干地支有'己'或者'酉'的，则为学堂。
                    7、年干或日干为庚，并且其他天干地支有'辛'或者'巳'的，则为学堂。
                    8、年干或日干为辛，并且其他天干地支有'甲'或者'子'的，则为学堂。
                    9、年干或日干为壬，并且其他天干地支有'甲'或者'申'的，则为学堂。
                    10、年干或日干为癸，并且其他天干地支有'乙'或者'卯'的，则为学堂。
         */

        {
            put(Constant.JIA_GAN, Arrays.asList(Constant.JI_GAN, Constant.HAI_ZHI));    // 年干或日干为甲，并且其他天干地支有'已'或者'亥'的，则为学堂。
            put(Constant.YI_GAN, Arrays.asList(Constant.REN_GAN, Constant.WU_ZHI));     // 年干或日干为乙，并且其他天干地支有'壬'或者'午'的，则为学堂。
            put(Constant.BING_GAN, Arrays.asList(Constant.BING_GAN, Constant.YIN_ZHI)); // 年干或日干为丙，并且其他天干地支有'丙'或者'寅'的，则为学堂。
            put(Constant.DING_GAN, Arrays.asList(Constant.DING_GAN, Constant.YOU_ZHI)); // 年干或日干为丁，并且其他天干地支有'丁'或者'酉'的，则为学堂。
            put(Constant.WU_GAN, Arrays.asList(Constant.WU_GAN, Constant.YIN_ZHI));     // 年干或日干为戊，并且其他天干地支有'戊'或者'寅'的，则为学堂。
            put(Constant.JI_GAN, Arrays.asList(Constant.JI_GAN, Constant.YOU_ZHI));     // 年干或日干为己，并且其他天干地支有'己'或者'酉'的，则为学堂。
            put(Constant.GENG_GAN, Arrays.asList(Constant.XIN_GAN, Constant.SI_ZHI));   // 年干或日干为庚，并且其他天干地支有'辛'或者'巳'的，则为学堂。
            put(Constant.XIN_GAN, Arrays.asList(Constant.JIA_GAN, Constant.ZI_ZHI));    // 年干或日干为辛，并且其他天干地支有'甲'或者'子'的，则为学堂。
            put(Constant.REN_GAN, Arrays.asList(Constant.JIA_GAN, Constant.SHEN_ZHI));  // 年干或日干为壬，并且其他天干地支有'甲'或者'申'的，则为学堂。
            put(Constant.GUI_GAN, Arrays.asList(Constant.YI_GAN, Constant.MAO_ZHI));    // 年干或日干为癸，并且其他天干地支有'乙'或者'卯'的，则为学堂。
        }

    };

    /**
     * 词馆
     */
    public static final Map<String, List<String>> CI_GUAN = new HashMap<String, List<String>>() {
        private static final long serialVersionUID = -1;

        /*
            【词馆】算法↓

                一、禄命法：（以年柱纳音查月支、日支、时支）
                    1、年命属木，月支或日支或时支有'寅'的，则为词馆。（'庚寅'为正词馆）
                    2、年命属火，月支或日支或时支有'巳'的，则为词馆。（'乙巳'为正词馆）
                    3、年命属土，月支或日支或时支有'亥'的，则为词馆。（'丁亥'为正词馆）
                    4、年命属金，月支或日支或时支有'申'的，则为词馆。（'壬申'为正词馆）
                    5、年命属水，月支或日支或时支有'亥'的，则为词馆。（'癸亥'为正词馆）


                二、子平法：（以年干、日干查四柱）★
                    1、年干或日干为甲，并且其他天干地支有'已'或者'亥'的，则为词馆。
                    2、年干或日干为乙，并且其他天干地支有'壬'或者'午'的，则为词馆。
                    3、年干或日干为丙，并且其他天干地支有'丙'或者'寅'的，则为词馆。
                    4、年干或日干为丁，并且其他天干地支有'丁'或者'酉'的，则为词馆。
                    5、年干或日干为戊，并且其他天干地支有'戊'或者'寅'的，则为词馆。
                    6、年干或日干为己，并且其他天干地支有'己'或者'酉'的，则为词馆。
                    7、年干或日干为庚，并且其他天干地支有'辛'或者'巳'的，则为词馆。
                    8、年干或日干为辛，并且其他天干地支有'甲'或者'子'的，则为词馆。
                    9、年干或日干为壬，并且其他天干地支有'甲'或者'申'的，则为词馆。
                    10、年干或日干为癸，并且其他天干地支有'乙'或者'卯'的，则为词馆。
         */

        {
            put(Constant.JIA_GAN, Arrays.asList(Constant.GENG_GAN, Constant.YIN_ZHI));  // 日干为甲，并且其他天干地支有'庚'或者'寅'的，则为词馆。
            put(Constant.YI_GAN, Arrays.asList(Constant.XIN_GAN, Constant.MAO_ZHI));    // 日干为乙，并且其他天干地支有'辛'或者'卯'的，则为词馆。
            put(Constant.BING_GAN, Arrays.asList(Constant.YI_GAN, Constant.SI_ZHI));    // 日干为丙，并且其他天干地支有'乙'或者'巳'的，则为词馆。
            put(Constant.DING_GAN, Arrays.asList(Constant.WU_GAN, Constant.WU_ZHI));    // 日干为丁，并且其他天干地支有'戊'或者'午'的，则为词馆。
            put(Constant.WU_GAN, Arrays.asList(Constant.DING_GAN, Constant.SI_ZHI));    // 日干为戊，并且其他天干地支有'丁'或者'巳'的，则为词馆。
            put(Constant.JI_GAN, Arrays.asList(Constant.GENG_GAN, Constant.WU_ZHI));    // 日干为己，并且其他天干地支有'庚'或者'午'的，则为词馆。
            put(Constant.GENG_GAN, Arrays.asList(Constant.REN_GAN, Constant.SHEN_ZHI)); // 日干为庚，并且其他天干地支有'壬'或者'申'的，则为词馆。
            put(Constant.XIN_GAN, Arrays.asList(Constant.GUI_GAN, Constant.YOU_ZHI));   // 日干为辛，并且其他天干地支有'癸'或者'酉'的，则为词馆。
            put(Constant.REN_GAN, Arrays.asList(Constant.GUI_GAN, Constant.HAI_ZHI));   // 日干为壬，并且其他天干地支有'癸'或者'亥'的，则为词馆。
            put(Constant.GUI_GAN, Arrays.asList(Constant.REN_GAN, Constant.XU_ZHI));    // 日干为癸，并且其他天干地支有'壬'或者'戌'的，则为词馆。
        }

    };

    /**
     * 金舆
     */
    public static final Map<String, String> JIN_YU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【金舆】算法↓

                1、年干或日干为甲，并且其他地支有'辰'的，则为金舆。
                2、年干或日干为乙，并且其他地支有'巳'的，则为金舆。
                3、年干或日干为丙，并且其他地支有'未'的，则为金舆。
                4、年干或日干为丁，并且其他地支有'申'的，则为金舆。
                5、年干或日干为戊，并且其他地支有'未'的，则为金舆。
                6、年干或日干为己，并且其他地支有'申'的，则为金舆。
                7、年干或日干为庚，并且其他地支有'戌'的，则为金舆。
                8、年干或日干为辛，并且其他地支有'亥'的，则为金舆。
                9、年干或日干为壬，并且其他地支有'丑'的，则为金舆。
                10、年干或日干为癸，并且其他地支有'寅'的，则为金舆。
         */

        {
            put(Constant.JIA_GAN, Constant.CHEN_ZHI);  // 年干或日干为甲，并且其他地支有'辰'的，则为金舆。
            put(Constant.YI_GAN, Constant.SI_ZHI);     // 年干或日干为乙，并且其他地支有'巳'的，则为金舆。
            put(Constant.BING_GAN, Constant.WEI_ZHI);  // 年干或日干为丙，并且其他地支有'未'的，则为金舆。
            put(Constant.DING_GAN, Constant.SHEN_ZHI); // 年干或日干为丁，并且其他地支有'申'的，则为金舆。
            put(Constant.WU_GAN, Constant.WEI_ZHI);    // 年干或日干为戊，并且其他地支有'未'的，则为金舆。
            put(Constant.JI_GAN, Constant.SHEN_ZHI);   // 年干或日干为己，并且其他地支有'申'的，则为金舆。
            put(Constant.GENG_GAN, Constant.XU_ZHI);   // 年干或日干为庚，并且其他地支有'戌'的，则为金舆。
            put(Constant.XIN_GAN, Constant.HAI_ZHI);   // 年干或日干为辛，并且其他地支有'亥'的，则为金舆。
            put(Constant.REN_GAN, Constant.CHOU_ZHI);  // 年干或日干为壬，并且其他地支有'丑'的，则为金舆。
            put(Constant.GUI_GAN, Constant.YIN_ZHI);   // 年干或日干为癸，并且其他地支有'寅'的，则为金舆。
        }

    };

    /**
     * 灾煞
     */
    public static final Map<String, String> ZAI_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【灾煞】算法↓

                1、年支为子，并且其他地支有'午'的，则为灾煞。
                2、年支为丑，并且其他地支有'卯'的，则为灾煞。
                3、年支为寅，并且其他地支有'子'的，则为灾煞。
                4、年支为卯，并且其他地支有'酉'的，则为灾煞。
                5、年支为辰，并且其他地支有'午'的，则为灾煞。
                6、年支为巳，并且其他地支有'卯'的，则为灾煞。
                7、年支为午，并且其他地支有'子'的，则为灾煞。
                8、年支为未，并且其他地支有'酉'的，则为灾煞。
                9、年支为申，并且其他地支有'午'的，则为灾煞。
                10、年支为酉，并且其他地支有'卯'的，则为灾煞。
                11、年支为戌，并且其他地支有'子'的，则为灾煞。
                12、年支为亥，并且其他地支有'酉'的，则为灾煞。
         */

        {
            put(Constant.ZI_ZHI, Constant.WU_ZHI);    // 年地支为'子'，则灾煞在'午'。
            put(Constant.CHOU_ZHI, Constant.MAO_ZHI); // 年地支为'丑'，则灾煞在'卯'。
            put(Constant.YIN_ZHI, Constant.ZI_ZHI);   // 年地支为'寅'，则灾煞在'子'。
            put(Constant.MAO_ZHI, Constant.YOU_ZHI);  // 年地支为'卯'，则灾煞在'酉'。
            put(Constant.CHEN_ZHI, Constant.WU_ZHI);  // 年地支为'辰'，则灾煞在'午'。
            put(Constant.SI_ZHI, Constant.MAO_ZHI);   // 年地支为'巳'，则灾煞在'卯'。
            put(Constant.WU_ZHI, Constant.ZI_ZHI);    // 年地支为'午'，则灾煞在'子'。
            put(Constant.WEI_ZHI, Constant.YOU_ZHI);  // 年地支为'未'，则灾煞在'酉'。
            put(Constant.SHEN_ZHI, Constant.WU_ZHI);  // 年地支为'申'，则灾煞在'午'。
            put(Constant.YOU_ZHI, Constant.MAO_ZHI);  // 年地支为'酉'，则灾煞在'卯'。
            put(Constant.XU_ZHI, Constant.ZI_ZHI);    // 年地支为'戌'，则灾煞在'子'。
            put(Constant.HAI_ZHI, Constant.YOU_ZHI);  // 年地支为'亥'，则灾煞在'酉'。
        }

    };

    /**
     * 亡神
     */
    public static final Map<String, String> WANG_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【亡神】算法↓

                1、年支或日支是亥、卯、未，并且其他地支有'寅'的，则为亡神。
                2、年支或日支是巳、酉、丑，并且其他地支有'申'的，则为亡神。
                3、年支或日支是寅、午、戌，并且其他地支有'巳'的，则为亡神。
                4、年支或日支是申、子、辰，并且其他地支有'亥'的，则为亡神。
         */

        {
            put(Constant.ZI_ZHI, Constant.HAI_ZHI);    // 年支或日支是'子'，则驿马在'亥'。
            put(Constant.CHOU_ZHI, Constant.SHEN_ZHI); // 年支或日支是'丑'，则驿马在'申'。
            put(Constant.YIN_ZHI, Constant.SI_ZHI);    // 年支或日支是'寅'，则驿马在'巳'。
            put(Constant.MAO_ZHI, Constant.YIN_ZHI);   // 年支或日支是'卯'，则驿马在'寅'。
            put(Constant.CHEN_ZHI, Constant.HAI_ZHI);  // 年支或日支是'辰'，则驿马在'亥'。
            put(Constant.SI_ZHI, Constant.SHEN_ZHI);   // 年支或日支是'巳'，则驿马在'申'。
            put(Constant.WU_ZHI, Constant.SI_ZHI);     // 年支或日支是'午'，则驿马在'巳'。
            put(Constant.WEI_ZHI, Constant.YIN_ZHI);   // 年支或日支是'未'，则驿马在'寅'。
            put(Constant.SHEN_ZHI, Constant.HAI_ZHI);  // 年支或日支是'申'，则驿马在'亥'。
            put(Constant.YOU_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'酉'，则驿马在'申'。
            put(Constant.XU_ZHI, Constant.SI_ZHI);     // 年支或日支是'戌'，则驿马在'巳'。
            put(Constant.HAI_ZHI, Constant.YIN_ZHI);   // 年支或日支是'亥'，则驿马在'寅'。
        }

    };

    /**
     * 羊刃
     */
    public static final Map<String, String> YANG_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【羊刃】算法↓

                1、日干为甲，并且其他地支有'卯'的，则为羊刃。
                2、日干为乙，并且其他地支有'辰'的，则为羊刃。
                3、日干为丙，并且其他地支有'午'的，则为羊刃。
                4、日干为丁，并且其他地支有'未'的，则为羊刃。
                5、日干为戊，并且其他地支有'午'的，则为羊刃。
                6、日干为己，并且其他地支有'未'的，则为羊刃。
                7、日干为庚，并且其他地支有'酉'的，则为羊刃。
                8、日干为辛，并且其他地支有'戌'的，则为羊刃。
                9、日干为壬，并且其他地支有'子'的，则为羊刃。
                10、日干为癸，并且其他地支有'丑'的，则为羊刃。
         */

        {
            put(Constant.JIA_GAN, Constant.MAO_ZHI);  // 日干是甲，并且其他地支有'卯'的，则为羊刃；
            put(Constant.YI_GAN, Constant.CHEN_ZHI);  // 日干是乙，并且其他地支有'辰'的，则为羊刃；
            put(Constant.BING_GAN, Constant.WU_ZHI);  // 日干是丙，并且其他地支有'午'的，则为羊刃；
            put(Constant.DING_GAN, Constant.WEI_ZHI); // 日干是丁，并且其他地支有'未'的，则为羊刃；
            put(Constant.WU_GAN, Constant.WU_ZHI);    // 日干是戊，并且其他地支有'午'的，则为羊刃；
            put(Constant.JI_GAN, Constant.WEI_ZHI);   // 日干是己，并且其他地支有'未'的，则为羊刃；
            put(Constant.GENG_GAN, Constant.YOU_ZHI); // 日干是庚，并且其他地支有'酉'的，则为羊刃；
            put(Constant.XIN_GAN, Constant.XU_ZHI);   // 日干是辛，并且其他地支有'戌'的，则为羊刃；
            put(Constant.REN_GAN, Constant.ZI_ZHI);   // 日干是壬，并且其他地支有'子'的，则为羊刃；
            put(Constant.GUI_GAN, Constant.CHOU_ZHI); // 日干是癸，并且其他地支有'丑'的，则为羊刃。
        }

    };

    /**
     * 飞刃
     */
    public static final Map<String, String> FEI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【飞刃】算法↓

                1、日干为甲，并且其他地支有'酉'的，则为飞刃。
                2、日干为乙，并且其他地支有'寅'的，则为飞刃。
                3、日干为丙，并且其他地支有'子'的，则为飞刃。
                4、日干为丁，并且其他地支有'亥'的，则为飞刃。
                5、日干为戊，并且其他地支有''的，则为飞刃。
                6、日干为己，并且其他地支有''的，则为飞刃。
                7、日干为庚，并且其他地支有'卯'的，则为飞刃。
                8、日干为辛，并且其他地支有'寅'的，则为飞刃。
                9、日干为壬，并且其他地支有'午'的，则为飞刃。
                10、日干为癸，并且其他地支有'巳'的，则为飞刃。
         */

        {
            put(Constant.JIA_GAN, Constant.YOU_ZHI);  // 日干是甲，并且其他地支有'酉'的，则为飞刃；
            put(Constant.YI_GAN, Constant.YIN_ZHI);   // 日干是乙，并且其他地支有'寅'的，则为飞刃；
            put(Constant.BING_GAN, Constant.ZI_ZHI);  // 日干是丙，并且其他地支有'子'的，则为飞刃；
            put(Constant.DING_GAN, Constant.HAI_ZHI); // 日干是丁，并且其他地支有'亥'的，则为飞刃；
            put(Constant.WU_GAN, null);               // 日干是戊，并且其他地支有''的，则为飞刃；
            put(Constant.JI_GAN, null);               // 日干是己，并且其他地支有''的，则为飞刃；
            put(Constant.GENG_GAN, Constant.MAO_ZHI); // 日干是庚，并且其他地支有'卯'的，则为飞刃；
            put(Constant.XIN_GAN, Constant.YIN_ZHI);  // 日干是辛，并且其他地支有'寅'的，则为飞刃；
            put(Constant.REN_GAN, Constant.WU_ZHI);   // 日干是壬，并且其他地支有'午'的，则为飞刃；
            put(Constant.GUI_GAN, Constant.SI_ZHI);   // 日干是癸，并且其他地支有'巳'的，则为飞刃。
        }

    };

    /**
     * 血刃
     */
    public static final Map<String, String> XUE_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【血刃】算法↓

                1、月支为子，并且其他地支有'午'的，则为血刃。
                2、月支为丑，并且其他地支有'子'的，则为血刃。
                3、月支为寅，并且其他地支有'丑'的，则为血刃。
                4、月支为卯，并且其他地支有'未'的，则为血刃。
                5、月支为辰，并且其他地支有'寅'的，则为血刃。
                6、月支为巳，并且其他地支有'申'的，则为血刃。
                7、月支为午，并且其他地支有'卯'的，则为血刃。
                8、月支为未，并且其他地支有'酉'的，则为血刃。
                9、月支为申，并且其他地支有'辰'的，则为血刃。
                10、月支为酉，并且其他地支有'戌'的，则为血刃。
                11、月支为戌，并且其他地支有'巳'的，则为血刃。
                12、月支为亥，并且其他地支有'亥'的，则为血刃。
         */

        {
            put(Constant.ZI_ZHI, Constant.WU_ZHI);     // 日干是子，血刃在'午'；
            put(Constant.CHOU_ZHI, Constant.ZI_ZHI);   // 日干是丑，血刃在'子'；
            put(Constant.YIN_ZHI, Constant.CHOU_ZHI);  // 日干是寅，血刃在'丑'；
            put(Constant.MAO_ZHI, Constant.WEI_ZHI);   // 日干是卯，血刃在'未'；
            put(Constant.CHEN_ZHI, Constant.YIN_ZHI);  // 日干是辰，血刃在'寅'；
            put(Constant.SI_ZHI, Constant.SHEN_ZHI);   // 日干是巳，血刃在'申'；
            put(Constant.WU_ZHI, Constant.MAO_ZHI);    // 日干是午，血刃在'卯'；
            put(Constant.WEI_ZHI, Constant.YOU_ZHI);   // 日干是未，血刃在'酉'；
            put(Constant.SHEN_ZHI, Constant.CHEN_ZHI); // 日干是申，血刃在'辰'；
            put(Constant.YOU_ZHI, Constant.XU_ZHI);    // 日干是酉，血刃在'戌'；
            put(Constant.XU_ZHI, Constant.SI_ZHI);     // 日干是戌，血刃在'巳'；
            put(Constant.HAI_ZHI, Constant.HAI_ZHI);   // 日干是亥，血刃在'亥'；
        }

    };

    /**
     * 流霞
     */
    public static final Map<String, String> LIU_XIA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【流霞】算法↓

                1、日干为甲，并且其他地支有'酉'的，则为流霞。
                2、日干为乙，并且其他地支有'戌'的，则为流霞。
                3、日干为丙，并且其他地支有'未'的，则为流霞。
                4、日干为丁，并且其他地支有'申'的，则为流霞。
                5、日干为戊，并且其他地支有'巳'的，则为流霞。
                6、日干为己，并且其他地支有'午'的，则为流霞。
                7、日干为庚，并且其他地支有'辰'的，则为流霞。
                8、日干为辛，并且其他地支有'卯'的，则为流霞。
                9、日干为壬，并且其他地支有'亥'的，则为流霞。
                10、日干为癸，并且其他地支有'寅'的，则为流霞。
         */

        {
            put(Constant.JIA_GAN, Constant.YOU_ZHI);   // 日干是甲，并且其他地支有'酉'的，则为流霞；
            put(Constant.YI_GAN, Constant.XU_ZHI);     // 日干是乙，并且其他地支有'戌'的，则为流霞；
            put(Constant.BING_GAN, Constant.WEI_ZHI);  // 日干是丙，并且其他地支有'未'的，则为流霞；
            put(Constant.DING_GAN, Constant.SHEN_ZHI); // 日干是丁，并且其他地支有'申'的，则为流霞；
            put(Constant.WU_GAN, Constant.SI_ZHI);     // 日干是戊，并且其他地支有'巳'的，则为流霞；
            put(Constant.JI_GAN, Constant.WU_ZHI);     // 日干是己，并且其他地支有'午'的，则为流霞；
            put(Constant.GENG_GAN, Constant.CHEN_ZHI); // 日干是庚，并且其他地支有'辰'的，则为流霞；
            put(Constant.XIN_GAN, Constant.MAO_ZHI);   // 日干是辛，并且其他地支有'卯'的，则为流霞；
            put(Constant.REN_GAN, Constant.HAI_ZHI);   // 日干是壬，并且其他地支有'亥'的，则为流霞；
            put(Constant.GUI_GAN, Constant.YIN_ZHI);   // 日干是癸，并且其他地支有'寅'的，则为流霞。
        }

    };

    /**
     * 孤辰
     */
    public static final Map<String, String> GU_CHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【孤辰】算法↓

                1、年支为子，并且其他地支有'寅'的，则为孤辰。
                2、年支为丑，并且其他地支有'寅'的，则为孤辰。
                3、年支为寅，并且其他地支有'巳'的，则为孤辰。
                4、年支为卯，并且其他地支有'巳'的，则为孤辰。
                5、年支为辰，并且其他地支有'巳'的，则为孤辰。
                6、年支为巳，并且其他地支有'申'的，则为孤辰。
                7、年支为午，并且其他地支有'申'的，则为孤辰。
                8、年支为未，并且其他地支有'申'的，则为孤辰。
                9、年支为申，并且其他地支有'亥'的，则为孤辰。
                10、年支为酉，并且其他地支有'亥'的，则为孤辰。
                11、年支为戌，并且其他地支有'亥'的，则为孤辰。
                12、年支为亥，并且其他地支有'寅'的，则为孤辰。
         */

        {
            put(Constant.ZI_ZHI, Constant.YIN_ZHI);   // 年地支为'子'，则灾煞在'寅'。
            put(Constant.CHOU_ZHI, Constant.YIN_ZHI); // 年地支为'丑'，则灾煞在'寅'。
            put(Constant.YIN_ZHI, Constant.SI_ZHI);   // 年地支为'寅'，则灾煞在'巳'。
            put(Constant.MAO_ZHI, Constant.SI_ZHI);   // 年地支为'卯'，则灾煞在'巳'。
            put(Constant.CHEN_ZHI, Constant.SI_ZHI);  // 年地支为'辰'，则灾煞在'巳'。
            put(Constant.SI_ZHI, Constant.SHEN_ZHI);  // 年地支为'巳'，则灾煞在'申'。
            put(Constant.WU_ZHI, Constant.SHEN_ZHI);  // 年地支为'午'，则灾煞在'申'。
            put(Constant.WEI_ZHI, Constant.SHEN_ZHI); // 年地支为'未'，则灾煞在'申'。
            put(Constant.SHEN_ZHI, Constant.HAI_ZHI); // 年地支为'申'，则灾煞在'亥'。
            put(Constant.YOU_ZHI, Constant.HAI_ZHI);  // 年地支为'酉'，则灾煞在'亥'。
            put(Constant.XU_ZHI, Constant.HAI_ZHI);   // 年地支为'戌'，则灾煞在'亥'。
            put(Constant.HAI_ZHI, Constant.YIN_ZHI);  // 年地支为'亥'，则灾煞在'寅'。
        }

    };

    /**
     * 寡宿
     */
    public static final Map<String, String> SU_GUA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【寡宿】算法↓

                1、年支为子，并且其他地支有'戌'的，则为寡宿。
                2、年支为丑，并且其他地支有'戌'的，则为寡宿。
                3、年支为寅，并且其他地支有'丑'的，则为寡宿。
                4、年支为卯，并且其他地支有'丑'的，则为寡宿。
                5、年支为辰，并且其他地支有'丑'的，则为寡宿。
                6、年支为巳，并且其他地支有'辰'的，则为寡宿。
                7、年支为午，并且其他地支有'辰'的，则为寡宿。
                8、年支为未，并且其他地支有'辰'的，则为寡宿。
                9、年支为申，并且其他地支有'未'的，则为寡宿。
                10、年支为酉，并且其他地支有'未'的，则为寡宿。
                11、年支为戌，并且其他地支有'未'的，则为寡宿。
                12、年支为亥，并且其他地支有'戌'的，则为寡宿。
         */

        {
            put(Constant.ZI_ZHI, Constant.XU_ZHI);     // 年地支为'子'，则灾煞在'戌'。
            put(Constant.CHOU_ZHI, Constant.XU_ZHI);   // 年地支为'丑'，则灾煞在'戌'。
            put(Constant.YIN_ZHI, Constant.CHOU_ZHI);  // 年地支为'寅'，则灾煞在'丑'。
            put(Constant.MAO_ZHI, Constant.CHOU_ZHI);  // 年地支为'卯'，则灾煞在'丑'。
            put(Constant.CHEN_ZHI, Constant.CHOU_ZHI); // 年地支为'辰'，则灾煞在'丑'。
            put(Constant.SI_ZHI, Constant.CHEN_ZHI);   // 年地支为'巳'，则灾煞在'辰'。
            put(Constant.WU_ZHI, Constant.CHEN_ZHI);   // 年地支为'午'，则灾煞在'辰'。
            put(Constant.WEI_ZHI, Constant.CHEN_ZHI);  // 年地支为'未'，则灾煞在'辰'。
            put(Constant.SHEN_ZHI, Constant.WEI_ZHI);  // 年地支为'申'，则灾煞在'未'。
            put(Constant.YOU_ZHI, Constant.WEI_ZHI);   // 年地支为'酉'，则灾煞在'未'。
            put(Constant.XU_ZHI, Constant.WEI_ZHI);    // 年地支为'戌'，则灾煞在'未'。
            put(Constant.HAI_ZHI, Constant.XU_ZHI);    // 年地支为'亥'，则灾煞在'戌'。
        }

    };

    /**
     * 魁罡
     */
    public static final String[] KUI_GANG = {"戊戌", "庚辰", "庚戌", "壬辰"};

    /**
     * 天喜
     */
    public static final Map<String, String> TIAN_XI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天喜】算法↓

                1、年支为子，并且其他地支有'酉'的，则为天喜。
                2、年支为丑，并且其他地支有'申'的，则为天喜。
                3、年支为寅，并且其他地支有'未'的，则为天喜。
                4、年支为卯，并且其他地支有'午'的，则为天喜。
                5、年支为辰，并且其他地支有'巳'的，则为天喜。
                6、年支为巳，并且其他地支有'辰'的，则为天喜。
                7、年支为午，并且其他地支有'卯'的，则为天喜。
                8、年支为未，并且其他地支有'寅'的，则为天喜。
                9、年支为申，并且其他地支有'丑'的，则为天喜。
                10、年支为酉，并且其他地支有'子'的，则为天喜。
                11、年支为戌，并且其他地支有'亥'的，则为天喜。
                12、年支为亥，并且其他地支有'戌'的，则为天喜。
         */

        {
            put(Constant.ZI_ZHI, Constant.YOU_ZHI);    // 年地支为'子'，则灾煞在'酉'。
            put(Constant.CHOU_ZHI, Constant.SHEN_ZHI); // 年地支为'丑'，则灾煞在'申'。
            put(Constant.YIN_ZHI, Constant.WEI_ZHI);   // 年地支为'寅'，则灾煞在'未'。
            put(Constant.MAO_ZHI, Constant.WU_ZHI);    // 年地支为'卯'，则灾煞在'午'。
            put(Constant.CHEN_ZHI, Constant.SI_ZHI);   // 年地支为'辰'，则灾煞在'巳'。
            put(Constant.SI_ZHI, Constant.CHEN_ZHI);   // 年地支为'巳'，则灾煞在'辰'。
            put(Constant.WU_ZHI, Constant.MAO_ZHI);    // 年地支为'午'，则灾煞在'卯'。
            put(Constant.WEI_ZHI, Constant.YIN_ZHI);   // 年地支为'未'，则灾煞在'寅'。
            put(Constant.SHEN_ZHI, Constant.CHOU_ZHI); // 年地支为'申'，则灾煞在'丑'。
            put(Constant.YOU_ZHI, Constant.ZI_ZHI);    // 年地支为'酉'，则灾煞在'子'。
            put(Constant.XU_ZHI, Constant.HAI_ZHI);    // 年地支为'戌'，则灾煞在'亥'。
            put(Constant.HAI_ZHI, Constant.XU_ZHI);    // 年地支为'亥'，则灾煞在'戌'。
        }

    };

    /**
     * 天转
     */
    public static final Map<String, String> TIAN_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天转】算法↓

                3、月支是寅、卯、辰，并且日柱时是'乙卯'，则为天转。
                1、月支是巳、午、未，并且日柱时是'丙午'，则为天转。
                2、月支是申、酉、戌，并且日柱时是'辛酉'，则为天转。
                4、月支是亥、子、丑，并且日柱时是'壬子'，则为天转。
         */

        {
            put(Constant.ZI_ZHI, Constant.REN_GAN + Constant.ZI_ZHI);    // 月支为'子'，则灾煞在'壬子'。
            put(Constant.CHOU_ZHI, Constant.REN_GAN + Constant.ZI_ZHI);  // 月支为'丑'，则灾煞在'壬子'。
            put(Constant.YIN_ZHI, Constant.YI_GAN + Constant.MAO_ZHI);   // 月支为'寅'，则灾煞在'乙卯'。
            put(Constant.MAO_ZHI, Constant.YI_GAN + Constant.MAO_ZHI);   // 月支为'卯'，则灾煞在'乙卯'。
            put(Constant.CHEN_ZHI, Constant.YI_GAN + Constant.MAO_ZHI);  // 月支为'辰'，则灾煞在'乙卯'。
            put(Constant.SI_ZHI, Constant.BING_GAN + Constant.WU_ZHI);   // 月支为'巳'，则灾煞在'丙午'。
            put(Constant.WU_ZHI, Constant.BING_GAN + Constant.WU_ZHI);   // 月支为'午'，则灾煞在'丙午'。
            put(Constant.WEI_ZHI, Constant.BING_GAN + Constant.WU_ZHI);  // 月支为'未'，则灾煞在'丙午'。
            put(Constant.SHEN_ZHI, Constant.XIN_GAN + Constant.YOU_ZHI); // 月支为'申'，则灾煞在'辛酉'。
            put(Constant.YOU_ZHI, Constant.XIN_GAN + Constant.YOU_ZHI);  // 月支为'酉'，则灾煞在'辛酉'。
            put(Constant.XU_ZHI, Constant.XIN_GAN + Constant.YOU_ZHI);   // 月支为'戌'，则灾煞在'辛酉'。
            put(Constant.HAI_ZHI, Constant.REN_GAN + Constant.ZI_ZHI);   // 月支为'亥'，则灾煞在'壬子'。
        }

    };

    /**
     * 地转
     */
    public static final Map<String, String> DI_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【地转】算法↓

                3、月支是寅、卯、辰，并且日柱时是'辛卯'，则为天转。
                1、月支是巳、午、未，并且日柱时是'戊午'，则为天转。
                2、月支是申、酉、戌，并且日柱时是'癸酉'，则为天转。
                4、月支是亥、子、丑，并且日柱时是'丙子'，则为天转。
         */

        {
            put(Constant.ZI_ZHI, Constant.BING_GAN + Constant.ZI_ZHI);   // 月支为'子'，则灾煞在'丙子'。
            put(Constant.CHOU_ZHI, Constant.BING_GAN + Constant.ZI_ZHI); // 月支为'丑'，则灾煞在'丙子'。
            put(Constant.YIN_ZHI, Constant.XIN_GAN + Constant.MAO_ZHI);  // 月支为'寅'，则灾煞在'辛卯'。
            put(Constant.MAO_ZHI, Constant.XIN_GAN + Constant.MAO_ZHI);  // 月支为'卯'，则灾煞在'辛卯'。
            put(Constant.CHEN_ZHI, Constant.XIN_GAN + Constant.MAO_ZHI); // 月支为'辰'，则灾煞在'辛卯'。
            put(Constant.SI_ZHI, Constant.WU_GAN + Constant.WU_ZHI);     // 月支为'巳'，则灾煞在'戊午'。
            put(Constant.WU_ZHI, Constant.WU_GAN + Constant.WU_ZHI);     // 月支为'午'，则灾煞在'戊午'。
            put(Constant.WEI_ZHI, Constant.WU_GAN + Constant.WU_ZHI);    // 月支为'未'，则灾煞在'戊午'。
            put(Constant.SHEN_ZHI, Constant.GUI_GAN + Constant.YOU_ZHI); // 月支为'申'，则灾煞在'癸酉'。
            put(Constant.YOU_ZHI, Constant.GUI_GAN + Constant.YOU_ZHI);  // 月支为'酉'，则灾煞在'癸酉'。
            put(Constant.XU_ZHI, Constant.GUI_GAN + Constant.YOU_ZHI);   // 月支为'戌'，则灾煞在'癸酉'。
            put(Constant.HAI_ZHI, Constant.BING_GAN + Constant.ZI_ZHI);  // 月支为'亥'，则灾煞在'丙子'。
        }

    };

    /**
     * 丧门
     */
    public static final Map<String, String> SANG_MEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【丧门】算法↓

                1、年支或日支是子，并且其他地支有'寅'的，则为丧门；
                2、年支或日支是丑，并且其他地支有'卯'的，则为丧门；
                3、年支或日支是寅，并且其他地支有'辰'的，则为丧门；
                4、年支或日支是卯，并且其他地支有'巳'的，则为丧门；
                5、年支或日支是辰，并且其他地支有'午'的，则为丧门；
                6、年支或日支是巳，并且其他地支有'未'的，则为丧门；
                7、年支或日支是午，并且其他地支有'申'的，则为丧门；
                8、年支或日支是未，并且其他地支有'酉'的，则为丧门；
                9、年支或日支是申，并且其他地支有'戌'的，则为丧门；
                10、年支或日支是酉，并且其他地支有'寅'的，则为丧门；
                11、年支或日支是戌，并且其他地支有'卯'的，则为丧门；
                12、年支或日支是亥，并且其他地支有'辰'的，则为丧门。
         */

        {
            put(Constant.ZI_ZHI, Constant.YIN_ZHI);   // 年支或日支是'子'，则丧门在'寅'。
            put(Constant.CHOU_ZHI, Constant.MAO_ZHI); // 年支或日支是'丑'，则丧门在'卯'。
            put(Constant.YIN_ZHI, Constant.CHEN_ZHI); // 年支或日支是'寅'，则丧门在'辰'。
            put(Constant.MAO_ZHI, Constant.SI_ZHI);   // 年支或日支是'卯'，则丧门在'巳'。
            put(Constant.CHEN_ZHI, Constant.WU_ZHI);  // 年支或日支是'辰'，则丧门在'午'。
            put(Constant.SI_ZHI, Constant.WEI_ZHI);   // 年支或日支是'巳'，则丧门在'未'。
            put(Constant.WU_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'午'，则丧门在'申'。
            put(Constant.WEI_ZHI, Constant.YOU_ZHI);  // 年支或日支是'未'，则丧门在'酉'。
            put(Constant.SHEN_ZHI, Constant.XU_ZHI);  // 年支或日支是'申'，则丧门在'戌'。
            put(Constant.YOU_ZHI, Constant.HAI_ZHI);  // 年支或日支是'酉'，则丧门在'寅'。
            put(Constant.XU_ZHI, Constant.ZI_ZHI);    // 年支或日支是'戌'，则丧门在'卯'。
            put(Constant.HAI_ZHI, Constant.CHOU_ZHI); // 年支或日支是'亥'，则丧门在'辰'。
        }

    };

    /**
     * 吊客
     */
    public static final Map<String, String> DIAO_KE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【吊客】算法↓

                1、年支或日支是子，并且其他地支有'戌'的，则为吊客；
                2、年支或日支是丑，并且其他地支有'亥'的，则为吊客；
                3、年支或日支是寅，并且其他地支有'子'的，则为吊客；
                4、年支或日支是卯，并且其他地支有'丑'的，则为吊客；
                5、年支或日支是辰，并且其他地支有'寅'的，则为吊客；
                6、年支或日支是巳，并且其他地支有'卯'的，则为吊客；
                7、年支或日支是午，并且其他地支有'辰'的，则为吊客；
                8、年支或日支是未，并且其他地支有'巳'的，则为吊客；
                9、年支或日支是申，并且其他地支有'午'的，则为吊客；
                10、年支或日支是酉，并且其他地支有'未'的，则为吊客；
                11、年支或日支是戌，并且其他地支有'申'的，则为吊客；
                12、年支或日支是亥，并且其他地支有'酉'的，则为吊客。
         */

        {
            put(Constant.ZI_ZHI, Constant.XU_ZHI);    // 年支或日支是'子'，则丧门在'戌'。
            put(Constant.CHOU_ZHI, Constant.HAI_ZHI); // 年支或日支是'丑'，则丧门在'亥'。
            put(Constant.YIN_ZHI, Constant.ZI_ZHI);   // 年支或日支是'寅'，则丧门在'子'。
            put(Constant.MAO_ZHI, Constant.CHOU_ZHI); // 年支或日支是'卯'，则丧门在'丑'。
            put(Constant.CHEN_ZHI, Constant.YIN_ZHI); // 年支或日支是'辰'，则丧门在'寅'。
            put(Constant.SI_ZHI, Constant.MAO_ZHI);   // 年支或日支是'巳'，则丧门在'卯'。
            put(Constant.WU_ZHI, Constant.CHEN_ZHI);  // 年支或日支是'午'，则丧门在'辰'。
            put(Constant.WEI_ZHI, Constant.SI_ZHI);   // 年支或日支是'未'，则丧门在'巳'。
            put(Constant.SHEN_ZHI, Constant.WU_ZHI);  // 年支或日支是'申'，则丧门在'午'。
            put(Constant.YOU_ZHI, Constant.WEI_ZHI);  // 年支或日支是'酉'，则丧门在'未'。
            put(Constant.XU_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'戌'，则丧门在'申'。
            put(Constant.HAI_ZHI, Constant.YOU_ZHI);  // 年支或日支是'亥'，则丧门在'酉'。
        }

    };

    /**
     * 披麻
     */
    public static final Map<String, String> PI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【披麻】算法↓

                1、年支或日支是子，并且其他地支有'酉'的，则为披麻；
                2、年支或日支是丑，并且其他地支有'戌'的，则为披麻；
                3、年支或日支是寅，并且其他地支有'亥'的，则为披麻；
                4、年支或日支是卯，并且其他地支有'子'的，则为披麻；
                5、年支或日支是辰，并且其他地支有'丑'的，则为披麻；
                6、年支或日支是巳，并且其他地支有'寅'的，则为披麻；
                7、年支或日支是午，并且其他地支有'卯'的，则为披麻；
                8、年支或日支是未，并且其他地支有'辰'的，则为披麻；
                9、年支或日支是申，并且其他地支有'巳'的，则为披麻；
                10、年支或日支是酉，并且其他地支有'午'的，则为披麻；
                11、年支或日支是戌，并且其他地支有'未'的，则为披麻；
                12、年支或日支是亥，并且其他地支有'申'的，则为披麻。
         */

        {
            put(Constant.ZI_ZHI, Constant.YOU_ZHI);    // 年支或日支是'子'，则丧门在'酉'。
            put(Constant.CHOU_ZHI, Constant.XU_ZHI);   // 年支或日支是'丑'，则丧门在'戌'。
            put(Constant.YIN_ZHI, Constant.HAI_ZHI);   // 年支或日支是'寅'，则丧门在'亥'。
            put(Constant.MAO_ZHI, Constant.ZI_ZHI);    // 年支或日支是'卯'，则丧门在'子'。
            put(Constant.CHEN_ZHI, Constant.CHOU_ZHI); // 年支或日支是'辰'，则丧门在'丑'。
            put(Constant.SI_ZHI, Constant.YIN_ZHI);    // 年支或日支是'巳'，则丧门在'寅'。
            put(Constant.WU_ZHI, Constant.MAO_ZHI);    // 年支或日支是'午'，则丧门在'卯'。
            put(Constant.WEI_ZHI, Constant.CHEN_ZHI);  // 年支或日支是'未'，则丧门在'辰'。
            put(Constant.SHEN_ZHI, Constant.SI_ZHI);   // 年支或日支是'申'，则丧门在'巳'。
            put(Constant.YOU_ZHI, Constant.WU_ZHI);    // 年支或日支是'酉'，则丧门在'午'。
            put(Constant.XU_ZHI, Constant.WEI_ZHI);    // 年支或日支是'戌'，则丧门在'未'。
            put(Constant.HAI_ZHI, Constant.SHEN_ZHI);  // 年支或日支是'亥'，则丧门在'申'。
        }

    };

    /**
     * 八专
     */
    public static final String[] BA_ZHUAN = {"甲寅", "乙卯", "丁未", "戊戌", "己未", "庚申", "辛酉", "癸丑"};

    /**
     * 九丑
     */
    public static final String[] JIU_CHOU = {"戊子", "丁酉", "丁卯", "戊午", "己酉", "己卯", "壬子", "壬午", "辛卯"};

    /**
     * 拱禄
     */
    public static final Map<List<String>, String> GONG_LU = new HashMap<List<String>, String>() {
        private static final long serialVersionUID = -1;

        /*
            【拱禄】算法↓

                1、日柱为'癸亥'，时柱为'癸丑'，拱禄在'子'。
                2、日柱为'癸丑'，时柱为'癸亥'，拱禄在'子'。
                3、日柱为'丁巳'，时柱为'丁未'，拱禄在'午'。
                4、日柱为'己未'，时柱为'己巳'，拱禄在'午'。
                5、日柱为'戊辰'，时柱为'戊午'，拱禄在'巳'。
         */

        {
            put(Arrays.asList(Constant.GUI_GAN + Constant.HAI_ZHI, Constant.GUI_GAN + Constant.CHOU_ZHI), Constant.ZI_ZHI); // 日柱是'癸亥'，时柱是'癸丑'，拱禄在'子'。
            put(Arrays.asList(Constant.GUI_GAN + Constant.CHOU_ZHI, Constant.GUI_GAN + Constant.HAI_ZHI), Constant.ZI_ZHI); // 日柱是'癸丑'，时柱是'癸亥'，拱禄在'子'。
            put(Arrays.asList(Constant.DING_GAN + Constant.SI_ZHI, Constant.DING_GAN + Constant.WEI_ZHI), Constant.WU_ZHI); // 日柱是'丁巳'，时柱是'丁未'，拱禄在'午'。
            put(Arrays.asList(Constant.JI_GAN + Constant.WEI_ZHI, Constant.JI_GAN + Constant.SI_ZHI), Constant.SI_ZHI);     // 日柱是'己未'，时柱是'己巳'，拱禄在'午'。
            put(Arrays.asList(Constant.WU_GAN + Constant.CHEN_ZHI, Constant.WU_GAN + Constant.WU_ZHI), Constant.WU_ZHI);    // 日柱是'戊辰'，时柱是'戊午'，拱禄在'巳'。
        }

    };

    /**
     * 天赦
     */
    public static final Map<String, String> TIAN_SHE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        /*
            【天赦】算法↓

                1、月支是子，日柱为'甲子'，则为天赦；
                2、月支是丑，日柱为'甲子'，则为天赦；
                3、月支是寅，日柱为'戊寅'，则为天赦；
                4、月支是卯，日柱为'戊寅'，则为天赦；
                5、月支是辰，日柱为'戊寅'，则为天赦；
                6、月支是巳，日柱为'甲午'，则为天赦；
                7、月支是午，日柱为'甲午'，则为天赦；
                8、月支是未，日柱为'甲午'，则为天赦；
                9、月支是申，日柱为'戊申'，则为天赦；
                10、月支是酉，日柱为'戊申'，则为天赦；
                11、月支是戌，日柱为'戊申'，则为天赦；
                12、月支是亥，日柱为'甲子'，则为天赦。
         */

        {
            put(Constant.ZI_ZHI, Constant.JIA_GAN + Constant.ZI_ZHI);    // 月支是子，日柱为'甲子'，则为天赦；
            put(Constant.CHOU_ZHI, Constant.JIA_GAN + Constant.ZI_ZHI);  // 月支是丑，日柱为'甲子'，则为天赦；
            put(Constant.YIN_ZHI, Constant.WU_GAN + Constant.YIN_ZHI);   // 月支是寅，日柱为'戊寅'，则为天赦；
            put(Constant.MAO_ZHI, Constant.WU_GAN + Constant.YIN_ZHI);   // 月支是卯，日柱为'戊寅'，则为天赦；
            put(Constant.CHEN_ZHI, Constant.WU_GAN + Constant.YIN_ZHI);  // 月支是辰，日柱为'戊寅'，则为天赦；
            put(Constant.SI_ZHI, Constant.JIA_GAN + Constant.WU_ZHI);    // 月支是巳，日柱为'甲午'，则为天赦；
            put(Constant.WU_ZHI, Constant.JIA_GAN + Constant.WU_ZHI);    // 月支是午，日柱为'甲午'，则为天赦；
            put(Constant.WEI_ZHI, Constant.JIA_GAN + Constant.WU_ZHI);   // 月支是未，日柱为'甲午'，则为天赦；
            put(Constant.SHEN_ZHI, Constant.WU_GAN + Constant.SHEN_ZHI); // 月支是申，日柱为'戊申'，则为天赦；
            put(Constant.YOU_ZHI, Constant.WU_GAN + Constant.SHEN_ZHI);  // 月支是酉，日柱为'戊申'，则为天赦；
            put(Constant.XU_ZHI, Constant.WU_GAN + Constant.SHEN_ZHI);   // 月支是戌，日柱为'戊申'，则为天赦；
            put(Constant.HAI_ZHI, Constant.JIA_GAN + Constant.ZI_ZHI);   // 月支是亥，日柱为'甲子'，则为天赦。
        }

    };


}
